There is a PB example out there for Base64 encoding and decoding, but it relies on calling COM objects. (At least the few I found did..) i.e :
string ls_ret
oleobject lo_xml
oleobject lo_node
lo_xml = create oleobject
lo_xml.connecttonewobject("Microsoft.XMLDOM")
lo_node = lo_xml.createElement("b64")
lo_node.dataType = "bin.base64"
//Encode
lo_node.NodeTypedValue = Blob(as_data)
ls_ret = lo_node.Text
//Decode
//lo_node.Text = as_data
//ls_ret = String( lo_node.NodeTypedValue )
Destroy lo_node
Destroy lo_xml
return ls_ret
Well, I came across a situation where I needed to call PB functions from a PBNI interface. One of the functions called used the above function to decode base64. Well for a reason I've yet to figure out, calling PB from PBNI fails on "create oleobject". Fail. So I rewrote the base64 decoding and encoding to do it manually and remove the dependency of the oleobject. The math could probably be simplified in here..but im too lazy to think.
Note: Both only work with unicode strings (Default for PB strings)
Note2: I used code found here http://www.motobit.com/tips/detpg_Base64/ as a base (youll notice more in the decode section as I got lazier and didnt rename the variables..)
Encode:
public function string of_encode_base64 (string as_data);
string ls_data, ls_ret
string ls_base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
string ls_tmp
longlong ll_24bits, ll_tmp, ll_tmp2, ll_tmp3
longlong ll_1, ll_2, ll_3, ll_4, ll_i
long ll_newline_offset
ls_data = as_data
ls_ret = ""
SetNull( ll_tmp3 )
For ll_i = 1 To longlong( Len( ls_data ) + 1 )
//Create 24bit buffer from unicode
If IsNull( ll_tmp3 ) Then
//Reverse first two bytes
ll_tmp = Asc( Mid( ls_data, ll_i, 1 ) )
ll_tmp = (( ll_tmp - ( Int( ll_tmp / 256 ) * 256 ) ) * 256) + ( ll_tmp / 256 )
ll_i++
//Get 3rd byte and store 4th for later
ll_tmp2 = Asc( Mid( ls_data, ll_i, 1) )
ll_tmp3 = Int( ll_tmp2 / 256 )
ll_tmp2 = ( ll_tmp2 - ( ll_tmp3 * 256 ) )
ll_24bits = (256 * ll_tmp) + ll_tmp2
Else
//Reverse next char and add ll_tmp3 to the beginning to create our next 3 byte(24bit) buffer
ll_tmp = Asc( Mid( ls_data, ll_i, 1 ) )
ll_24bits = ( ll_tmp3 * 65536 ) + ( ( ll_tmp - ( Int( ll_tmp / 256 ) * 256 ) ) * 256 ) + ( Int( ll_tmp / 256 ) )
SetNull( ll_tmp3 )
End If
//Get each 6 bit indexes
ll_1 = Int( ll_24bits / 262144 ) //Shift 18 bits right to get first 6bit index
ll_24bits -= ll_1 * 262144 //remove first 6 bits from buffer
ll_2 = Int( ll_24bits / 4096 ) //Shift 12 bits right for 2nd
ll_24bits -= ll_2 * 4096 //Remove it from buffer
ll_3 = Int( ll_24bits / 64 ) //Shift 6 bits for third
ll_4 = ll_24bits - ( ll_3 * 64 ) // remove third and left with last 6 bit index
//Convert To base64
ls_ret += Mid( ls_base64, ll_1 + 1, 1 ) + Mid( ls_base64, ll_2 + 1, 1 ) + Mid( ls_base64, ll_3 + 1, 1 ) + + Mid( ls_base64, ll_4 + 1, 1 )
//Add a new line For Each 72 chars In dest
If Mod( Len( ls_ret ) - ll_newline_offset , 72 ) = 0 Then
ls_ret += "~r~n"
ll_newline_offset += 2
End If
Next
//Pad end
Choose Case Mod( Len( ls_data ) - 1, 3 )
Case 1 //8 bit final
ls_ret = Left( ls_ret, Len( ls_ret ) - 2 ) + "=="
Case 2 //16 bit final
ls_ret = Left( ls_ret, Len( ls_ret ) - 1 ) + "="
End Choose
return ls_ret
end function
Decode:
public function string of_dec_to_hex (long al_number);
// 0 <= n <= 15
// Converts integer from 0 - 15 into character hex representation
string sHexChar
Choose Case al_number
Case 10
sHexChar = 'A'
Case 11
sHexChar = 'B'
Case 12
sHexChar = 'C'
Case 13
sHexChar = 'D'
Case 14
sHexChar = 'E'
Case 15
sHexChar = 'F'
Case Else
sHexChar = String(al_number)
End Choose
Return sHexChar
end function
public function string of_convert_to_hex (long al_number);
// string of_convert_to_hex( long alNumber ), recursive:
// Recursive function to translate number into hex representation
If al_number > 15 Then
Return of_convert_to_hex( al_number / 16 ) + of_dec_to_hex( Mod( al_number, 16 ) )
Else
Return of_dec_to_hex( al_number )
End If
end function
public function long of_hex2long (string as_hex);
string ls_hex
integer i,length
long result = 0
length = len(as_hex)
ls_hex = Upper(as_hex)
FOR i = 1 to length
result += &
(Pos ('123456789ABCDEF', mid(ls_hex, i, 1)) * &
( 16 ^ ( length - i ) ))
NEXT
RETURN result
end function
public function string of_replace (string as_source, string as_replace, string as_with);
int ll_start = 1,ll_len
ll_len = len( as_replace )
ll_start = Pos( as_source, as_replace, ll_start )
Do While ll_start > 0
as_source = Replace( as_source, ll_start, ll_len, as_with )
ll_start = Pos( as_source, as_replace, ll_start + Len( as_with ) )
Loop
return as_source
end function
public function string of_decode_base64 (string as_base64);
string Base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
string ls_working
long dataLength, groupBegin, ll_mod
string sOut, pOut, ls_tmp
//remove white spaces, If any
ls_working = of_replace(as_base64, "~r", "")
ls_working = of_replace(as_base64, "~n", "")
ls_working = of_replace(ls_working, "~t", "")
ls_working = trim( ls_working )
dataLength = Len( ls_working )
If Mod(dataLength, 4) <> 0 Then
return ""
End If
//Now decode each group:
For groupBegin = 1 To dataLength Step 4
long numDataBytes, CharCounter, thisData, nGroup
char thisChar
//Each data group encodes up To 3 actual bytes.
numDataBytes = 3
nGroup = 0
For CharCounter = 0 To 3
/*
Convert each character into 6 bits of data, And add it To
an integer For temporary storage. If a character is a '=', there
is one fewer data byte. (There can only be a maximum of 2 '=' In
the whole string.)
*/
thisChar = Mid(ls_working, groupBegin + CharCounter, 1)
If thisChar = "=" Then
numDataBytes = numDataBytes - 1
thisData = 0
Else
thisData = Pos(Base64, thisChar, 1) - 1
End If
If thisData = -1 Then
return ""
End If
nGroup = 64 * nGroup + thisData
Next
//Hex splits the long To 6 groups with 4 bits
string ls_group
ls_group = of_convert_to_hex( nGroup )
//Add leading zeros
Do While Len(ls_group) < 6
ls_group = "0" + ls_group
Loop
//Converts two characters at a time accounting for Unicode and Little Endian
//Saves the third char for the next run
If ls_tmp <> "" Then
pOut = Char( of_hex2long( Mid( ls_group, 1, 2 ) + ls_tmp) )
pOut = pOut + Char( of_hex2long( Mid( ls_group, 5, 2 ) + Mid( ls_group, 3, 2) ) )
ls_tmp = ""
Else
pOut = Char( of_hex2long( Mid( ls_group, 3, 2 ) + Mid( ls_group, 1, 2) ) )
ls_tmp = Mid( ls_group, 5, 2 )
End If
//add numDataBytes characters To out string
sOut = sOut + Left(pOut, numDataBytes)
Next
return sOut
end function
Edit:
I got through with my Quiznos pretty quick today, so i decided to take a quick look at the comments about decoding base64 to a blob.
NOTE: I didn't spend very much time going over this (Im lazy!). I did however test it succesfully with two jpegs that where converted to base64 strings using C#'s Convert.ToBase64String
NOTE2: Encoding I did not even glance at. Your on your own there.
public function blob of_decode_base64_to_blob (string as_base64);
string ls_base_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
string ls_working
long ll_data_len, ll_start_from, ll_mod
string ls_tmp, ls_hex
long ll_num_bytes, ll_count, ll_this_pos, ll_dec
char lc_char
blob lb, lb_out
long ll_pos
ll_pos = 1
//remove white spaces, If any
ls_working = gnv_app.of_conv(as_base64, "~r", "")
ls_working = gnv_app.of_conv(as_base64, "~n", "")
ls_working = gnv_app.of_conv(ls_working, "~t", "")
ls_working = trim( ls_working )
ll_data_len = Len( ls_working )
If Mod(ll_data_len, 4) <> 0 Then
return lb
End If
lb = Blob(space(ll_data_len))
//Now decode each group:
For ll_start_from = 1 To ll_data_len Step 4
//Each data group encodes up To 3 actual bytes.
ll_num_bytes = 3
ll_dec = 0
For ll_count = 0 To 3
/*
Convert each character into 6 bits of data, And add it To
an integer For temporary storage. If a character is a '=', there
is one fewer data byte. (There can only be a maximum of 2 '=' In
the whole string.)
*/
lc_char = Mid(ls_working, ll_start_from + ll_count, 1)
If lc_char = "=" Then
ll_num_bytes = ll_num_bytes - 1
ll_this_pos = 0
Else
ll_this_pos = Pos(ls_base_chars, lc_char, 1) - 1
End If
If ll_this_pos = -1 Then
return lb
End If
ll_dec = 64 * ll_dec + ll_this_pos
Next
//Hex splits the long To 6 groups with 4 bits
ls_hex = of_convert_to_hex( ll_dec )
//Add leading zeros
Do While Len(ls_hex) < 6
ls_hex = "0" + ls_hex
Loop
//Converts two characters at a time accounting for Little Endian
//Saves the third char for the next run
If ls_tmp <> "" Then
//Add first two byte
BlobEdit(lb, ll_pos, of_hexlong( Mid( ls_hex, 1, 2 ) + ls_tmp))
ll_pos += 2
//Add next two bytes
BlobEdit(lb, ll_pos, of_hexlong( Mid( ls_hex, 5, 2 ) + Mid( ls_hex, 3, 2) ) )
ll_pos += 2
ls_tmp = ""
Else
//Add two bytes
BlobEdit(lb, ll_pos, of_hexlong( Mid( ls_hex, 3, 2 ) + Mid(ls_hex, 1, 2)) )
ll_pos += 2
//Save third
ls_tmp = Mid( ls_hex, 5, 2 )
End If
//Adjust position as needed
ll_pos = ll_pos - (3 - ll_num_bytes)
Next
lb_out = BlobMid(lb, 1, ll_pos)
return lb_out
end function
