b2_upload_file

Code

FILE_TO_UPLOAD=typing_test.txt
MIME_TYPE=text/plain
SHA1_OF_FILE=$(openssl dgst -sha1 $FILE_TO_UPLOAD | awk '{print $2;}')
UPLOAD_URL=... # from b2_get_upload_url call
UPLOAD_AUTHORIZATION_TOKEN=... # from b2_get_upload_url call

curl \
    -H "Authorization: $UPLOAD_AUTHORIZATION_TOKEN" \
    -H "X-Bz-File-Name: $FILE_TO_UPLOAD" \
    -H "Content-Type: $MIME_TYPE" \
    -H "X-Bz-Content-Sha1: $SHA1_OF_FILE" \
    -H "X-Bz-Info-Author: unknown" \
    -H "X-Bz-Server-Side-Encryption: AES256" \
    --data-binary "@$FILE_TO_UPLOAD" \
    $UPLOAD_URL

Output

{
    "fileId" : "4_h4a48fe8875c6214145260818_f000000000000472a_d20140104_m032022_c001_v0000123_t0104",
    "fileName" : "typing_test.txt",
    "accountId" : "12f634bf3cbz",
    "bucketId" : "4a48fe8875c6214145260818",
    "contentLength" : 46,
    "contentSha1" : "bae5ed658ab3546aee12f23f36392f35dba1ebdd",
    "contentType" : "text/plain",
    "fileInfo" : {
       "author" : "unknown"
    },
    "fileRetention": {
      "isClientAuthorizedToRead": true,
      "value": {
        "mode": null,
        "retainUntilTimestamp": null
      }
    },
    "legalHold": {
      "isClientAuthorizedToRead": true,
      "value": null
    },
    "serverSideEncryption" : {
       "algorithm" : "AES256",
       "mode" : "SSE-B2"
    }
}

Code

import java.io.*;
import java.util.*;
import javax.json.*;
import java.net.HttpURLConnection;
import java.net.URL;

String uploadUrl = ""; // Provided by b2_get_upload_url
String uploadAuthorizationToken = ""; // Provided by b2_get_upload_url
String fileName = "typing_test.txt"; // The name of the file you are uploading
String contentType = "text/plain"; // The content type of the file
String sha1 = "bae5ed658ab3546aee12f23f36392f35dba1ebdd"; // SHA1 of the file you are uploading
byte[] fileData;
HttpURLConnection connection = null;
String json = null;
try {
    URL url = new URL(uploadUrl);
    connection = (HttpURLConnection)url.openConnection();
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Authorization", uploadAuthorizationToken);
    connection.setRequestProperty("Content-Type", contentType);
    connection.setRequestProperty("X-Bz-File-Name", fileName);
    connection.setRequestProperty("X-Bz-Content-Sha1", sha1);
    connection.setRequestProperty("X-Bz-Info-Author", "unknown");
    connection.setRequestProperty("X-Bz-Server-Side-Encryption", "AES256");
    connection.setDoOutput(true);
    DataOutputStream writer = new DataOutputStream(connection.getOutputStream());
    writer.write(fileData);
    String jsonResponse = myInputStreamReader(connection.getInputStream());
    System.out.println(jsonResponse);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    connection.disconnect();
}

static public String myInputStreamReader(InputStream in) throws IOException {
    InputStreamReader reader = new InputStreamReader(in);
    StringBuilder sb = new StringBuilder();
    int c = reader.read();
    while (c != -1) {
        sb.append((char)c);
        c = reader.read();
    }
    reader.close();
    return sb.toString();
}

Output

{
    "fileId" : "4_h4a48fe8875c6214145260818_f000000000000472a_d20140104_m032022_c001_v0000123_t0104",
    "fileName" : "typing_test.txt",
    "accountId" : "12f634bf3cbz",
    "bucketId" : "4a48fe8875c6214145260818",
    "contentLength" : 46,
    "contentSha1" : "bae5ed658ab3546aee12f23f36392f35dba1ebdd",
    "contentType" : "text/plain",
    "fileInfo" : {
       "author" : "unknown"
    },
    "fileRetention": {
      "isClientAuthorizedToRead": true,
      "value": {
        "mode": null,
        "retainUntilTimestamp": null
      }
    },
    "legalHold": {
      "isClientAuthorizedToRead": true,
      "value": null
    },
    "serverSideEncryption" : {
       "algorithm" : "AES256",
       "mode" : "SSE-B2"
    }
}

Code

import json
import urllib2
import hashlib

upload_url = "" # Provided by b2_get_upload_url
upload_authorization_token = "" # Provided by b2_get_upload_url
file_data = "Now, I am become Death, the destroyer of worlds."
file_name = "typing_test.txt"
content_type = "text/plain"
sha1_of_file_data = hashlib.sha1(file_data).hexdigest()

headers = {
    'Authorization' : upload_authorization_token,
    'X-Bz-File-Name' :  file_name,
    'Content-Type' : content_type,
    'X-Bz-Content-Sha1' : sha1_of_file_data,
    'X-Bz-Info-Author' : 'unknown',
    'X-Bz-Server-Side-Encryption' : 'AES256'
    }
request = urllib2.Request(upload_url, file_data, headers)

response = urllib2.urlopen(request)
response_data = json.loads(response.read())
response.close()

Output

{
    "fileId" : "4_h4a48fe8875c6214145260818_f000000000000472a_d20140104_m032022_c001_v0000123_t0104",
    "fileName" : "typing_test.txt",
    "accountId" : "12f634bf3cbz",
    "bucketId" : "4a48fe8875c6214145260818",
    "contentLength" : 46,
    "contentSha1" : "bae5ed658ab3546aee12f23f36392f35dba1ebdd",
    "contentType" : "text/plain",
    "fileInfo" : {
       "author" : "unknown"
    },
    "fileRetention": {
      "isClientAuthorizedToRead": true,
      "value": {
        "mode": null,
        "retainUntilTimestamp": null
      }
    },
    "legalHold": {
      "isClientAuthorizedToRead": true,
      "value": null
    },
    "serverSideEncryption" : {
       "algorithm" : "AES256",
       "mode" : "SSE-B2"
    }
}

Code

import Foundation

let uploadUrl = "" // Provided by b2_get_upload_url
let uploadAuthorizationToken = "" // Provided by b2_get_upload_url
let fileName = "typing_test.txt" // The name of the file you are uploading
let contentType = "text/plain" // The content type of the file
let sha1 = "bae5ed658ab3546aee12f23f36392f35dba1ebdd" // SHA1 of the file you are uploading

var fileData: Data?
do {
	// Read file into memory
	let fileData = try Data(contentsOf: URL(fileURLWithPath: "<path_to_a_file>"))
} catch (let error) {
	print("\(error.localizedDescription)")
}
	
// Create request
var request = URLRequest(url: uploadUrl)
request.httpMethod = "POST"
request.addValue(uploadAuthorizationToken, forHTTPHeaderField: "Authorization")
request.addValue(fileName, forHTTPHeaderField: "X-Bz-File-Name")
request.addValue(contentType, forHTTPHeaderField: "Content-Type")
request.addValue(sha1, forHTTPHeaderField: "X-Bz-Content-Sha1")
request.addValue("unknown", forHTTPHeaderField: "X-Bz-Info-Author")
request.addValue("AES256", forHTTPHeaderField: "X-Bz-Server-Side-Encryption")

// Create task
let task = URLSession.shared.uploadTask(with: request, from: fileData) { (data, response, error) in
	if let data = data {
		let json = String(data: data, encoding: .utf8)
		print("\(json!)")
	}
}

// Start task
task.resume()

// Swift 4.1 (swiftlang-902.0.48 clang-902.0.37.1) Xcode 9.3.1 (9E501)

Output

{
    "fileId": "4_h4a48fe8875c6214145260818_f000000000000472a_d20140104_m032022_c001_v0000123_t0104",
    "fileName": "typing_test.txt",
    "accountId": "12f634bf3cbz",
    "bucketId": "4a48fe8875c6214145260818",
    "contentLength": 46,
    "contentSha1": "bae5ed658ab3546aee12f23f36392f35dba1ebdd",
    "contentType": "text/plain",
    "fileInfo": {
       "author": "unknown"
    },
    "fileRetention": {
      "isClientAuthorizedToRead": true,
      "value": {
        "mode": null,
        "retainUntilTimestamp": null
      }
    },
    "legalHold": {
      "isClientAuthorizedToRead": true,
      "value": null
    },
    "serverSideEncryption": {
       "algorithm": "AES256",
       "mode": "SSE-B2"
    }
}

Code

require 'json'
require 'net/http'
require 'digest/sha1'

upload_url = "" # Provided by b2_get_upload_url
local_file = "" # File to be uploaded
upload_authorization_token = "" # Provided by b2_get_upload_url
file_name = "typing_test.txt" # The name of the file you are uploading
content_type = "text/plain"  # The content type of the file
sha1 = "bae5ed658ab3546aee12f23f36392f35dba1ebdd" # SHA1 of the file you are uploading
uri = URI(upload_url)
req = Net::HTTP::Post.new(uri)
req.add_field("Authorization","#{upload_authorization_token}")
req.add_field("X-Bz-File-Name","#{file_name}")
req.add_field("Content-Type","#{content_type}")
req.add_field("X-Bz-Content-Sha1","#{sha1}")
req.add_field("Content-Length",File.size(local_file))
req.add_field("X-Bz-Info-Author","unknown")
req.add_field("X-Bz-Server-Side-Encryption","AES256")
req.body = File.read(local_file)
http = Net::HTTP.new(req.uri.host, req.uri.port)
http.use_ssl = (req.uri.scheme == 'https')
res = http.start {|http| http.request(req)}
case res
when Net::HTTPSuccess then
    res.body
when Net::HTTPRedirection then
    fetch(res['location'], limit - 1)
else
    res.error!
end

Output

{
    "fileId": "4_h4a48fe8875c6214145260818_f000000000000472a_d20140104_m032022_c001_v0000123_t0104",
    "fileName": "typing_test.txt",
    "accountId": "12f634bf3cbz",
    "bucketId": "4a48fe8875c6214145260818",
    "contentLength": 46,
    "contentSha1": "bae5ed658ab3546aee12f23f36392f35dba1ebdd",
    "contentType": "text/plain",
    "fileInfo": {
       "author": "unknown"
    },
    "fileRetention": {
      "isClientAuthorizedToRead": true,
      "value": {
        "mode": null,
        "retainUntilTimestamp": null
      }
    },
    "legalHold": {
      "isClientAuthorizedToRead": true,
      "value": null
    },
    "serverSideEncryption": {
       "algorithm": "AES256",
       "mode": "SSE-B2"
    }
}

Code

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Security.Cryptography;

String uploadAuthorizationToken = "UPLOAD_AUTHORIZATION_TOKEN"; //Provided by b2_get_upload_url
String contentType = "text/plain"; //Type of file i.e. image/jpeg, audio/mpeg...
String filePath = "FILE_PATH"; //File path of desired upload 
String fileName = "typing_test.txt"; //Desired name for the file
String sha1Str = ""; //Sha1 verification for the file

// Read the file into memory and take a sha1 of the data.
FileInfo fileInfo = new FileInfo(filePath);
byte[] bytes = File.ReadAllBytes(filePath);
SHA1 sha1 = SHA1.Create();
// NOTE: Loss of precision. You may need to change this code if the file size is larger than 32-bits.
byte[] hashData = sha1.ComputeHash(bytes, 0, (int)fileInfo.Length);
StringBuilder sb = new StringBuilder();
foreach (byte b in hashData)
{
	sb.Append(b.ToString("x2"));
}
sha1Str = sb.ToString();

// Send over the wire
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uploadUrl);
webRequest.Method = "POST";
webRequest.Headers.Add("Authorization", uploadAuthorizationToken);
webRequest.Headers.Add("X-Bz-File-Name", fileName);
webRequest.Headers.Add("X-Bz-Content-Sha1", sha1Str);
webRequest.Headers.Add("X-Bz-Info-Author", "unknown");
webRequest.Headers.Add("X-Bz-Server-Side-Encryption", "AES256");
webRequest.ContentType = contentType;
using (var stream = webRequest.GetRequestStream())
{
	stream.Write(bytes, 0, bytes.Length);
	stream.Close();
}
WebResponse response = (HttpWebResponse)webRequest.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
response.Close();
Console.WriteLine(responseString);

Output

{
    "fileId" : "4_h4a48fe8875c6214145260818_f000000000000472a_d20140104_m032022_c001_v0000123_t0104",
    "fileName" : "typing_test.txt",
    "accountId" : "12f634bf3cbz",
    "bucketId" : "4a48fe8875c6214145260818",
    "contentLength" : 46,
    "contentSha1" : "bae5ed658ab3546aee12f23f36392f35dba1ebdd",
    "contentType" : "text/plain",
    "fileInfo" : {
       "author" : "unknown"
    },
    "fileRetention": {
      "isClientAuthorizedToRead": true,
      "value": {
        "mode": null,
        "retainUntilTimestamp": null
      }
    },
    "legalHold": {
      "isClientAuthorizedToRead": true,
      "value": null
    },
    "serverSideEncryption" : {
       "algorithm" : "AES256",
       "mode" : "SSE-B2"
    }
}

Code

$file_name = "typing_test.txt";
$my_file = "<path-to-file>" . $file_name;
$handle = fopen($my_file, 'r');
$read_file = fread($handle,filesize($my_file));

$upload_url = ""; // Provided by b2_get_upload_url
$upload_auth_token = ""; // Provided by b2_get_upload_url
$bucket_id = "";  // The ID of the bucket
$content_type = "text/plain";
$sha1_of_file_data = sha1_file($my_file);

$session = curl_init($upload_url);

// Add read file as post field
curl_setopt($session, CURLOPT_POSTFIELDS, $read_file); 

// Add headers
$headers = array();
$headers[] = "Authorization: " . $upload_auth_token;
$headers[] = "X-Bz-File-Name: " . $file_name;
$headers[] = "Content-Type: " . $content_type;
$headers[] = "X-Bz-Content-Sha1: " . $sha1_of_file_data;
$headers[] = "X-Bz-Info-Author: " . "unknown";
$headers[] = "X-Bz-Server-Side-Encryption: " . "AES256";
curl_setopt($session, CURLOPT_HTTPHEADER, $headers); 

curl_setopt($session, CURLOPT_POST, true); // HTTP POST
curl_setopt($session, CURLOPT_RETURNTRANSFER, true);  // Receive server response
$server_output = curl_exec($session); // Let's do this!
curl_close ($session); // Clean up
echo ($server_output); // Tell me about the rabbits, George!

Output

{
    "fileId" : "4_h4a48fe8875c6214145260818_f000000000000472a_d20140104_m032022_c001_v0000123_t0104",
    "fileName" : "typing_test.txt",
    "accountId" : "12f634bf3cbz",
    "bucketId" : "4a48fe8875c6214145260818",
    "contentLength" : 46,
    "contentSha1" : "bae5ed658ab3546aee12f23f36392f35dba1ebdd",
    "contentType" : "text/plain",
    "fileInfo" : {
       "author" : "unknown"
    },
    "fileRetention": {
      "isClientAuthorizedToRead": true,
      "value": {
        "mode": null,
        "retainUntilTimestamp": null
      }
    },
    "legalHold": {
      "isClientAuthorizedToRead": true,
      "value": null
    },
    "serverSideEncryption" : {
       "algorithm" : "AES256",
       "mode" : "SSE-B2"
    }
}