Simba Code:
{$loadlib ProSock}
type
MAIL = record
{$IFNDEF CODEINSIGHT}
__Address: String;
__Username: String;
__EncryptedUsername: String;
__EncryptedPassword: String;
__Receiver: String;
__FromName: String;
__ToName: String;
__Subject: String;
__Message: String;
__BufferSize: Integer;
__ssl_info: SSLSocket;
{$ENDIF}
end;
type
HTTPS = record
{$IFNDEF CODEINSIGHT}
__Headers: Array Of String;
__ParameterKeys: Array Of String;
__ParameterValues: Array Of String;
__Host: String;
__Address: String;
__BufferSize: Integer;
__ssl_info: SSLSocket;
{$ENDIF}
end;
{$IFNDEF CODEINSIGHT}
var
__Pro_Socket_Terminate_MAIL_Array: Array of ^SSLSocket;
__Pro_Socket_Terminate_HTTPS_Array: Array of ^SSLSocket;
Procedure __Destroy_Pro_MAIL_Sockets;
var
I: Integer;
Begin
For I := 0 To High(__Pro_Socket_Terminate_MAIL_Array) Do
Pro_FreeSocket(__Pro_Socket_Terminate_MAIL_Array[I]);
SetLength(__Pro_Socket_Terminate_MAIL_Array, 0);
End;
Procedure __Destroy_Pro_HTTPS_Sockets;
var
I: Integer;
Begin
For I := 0 To High(__Pro_Socket_Terminate_HTTPS_Array) Do
Pro_FreeSocket(__Pro_Socket_Terminate_HTTPS_Array[I]);
SetLength(__Pro_Socket_Terminate_HTTPS_Array, 0);
End;
Procedure __MemSet(Buffer: Pointer; Value: Byte; Size: Cardinal);
type
BytePtr = ^Byte;
var
I: Integer;
Begin
For I := 0 To Size Do
BytePtr(Buffer)[I]^ := Value;
End;
Procedure MAIL.__PrintSocket();
var
Buffer: String;
Bytes_Read: Integer;
Begin
SetLength(Buffer, self.__BufferSize);
__MemSet(@Buffer[1], 0, self.__BufferSize);
While((Bytes_Read := Pro_ReadSocket(@self.__ssl_info, @Buffer[1], self.__BufferSize)) > 0) Do
Begin
writeln(Trim(Buffer));
__MemSet(@Buffer[1], 0, self.__BufferSize);
If (Not Pro_IsPendingSocket(@self.__ssl_info)) Then
break;
End;
End;
{$ENDIF}
Procedure MAIL.Create(Address: String; Port: Word; Username, Password, MailTo: String);
Begin
Self.Create(Address, Port, Username, Password, MailTo, '');
End;
Procedure MAIL.Create(Address: String; Port: Word; Username, Password, MailTo, Subject: String) overload;
Begin
self.__Address := Address;
self.__ssl_info.port := Port;
self.__ssl_info.address := @self.__Address[1];
self.__ssl_info.socktype := SSLSocketType.SSL23_CLIENT_METHOD;
self.__EncryptedUsername := Base64Encode(Username);
self.__EncryptedPassword := Base64Encode(Password);
self.__Username := Username;
self.__Receiver := MailTo;
self.__Subject := Subject;
self.__BufferSize := 512;
Pro_CreateSocket(@self.__ssl_info);
Pro_ConnectSocket(@self.__ssl_info);
SetLength(__Pro_Socket_Terminate_MAIL_Array, Length(__Pro_Socket_Terminate_MAIL_Array) + 1);
__Pro_Socket_Terminate_MAIL_Array[High(__Pro_Socket_Terminate_MAIL_Array)] := @self.__ssl_info;
AddOnTerminate('__Destroy_Pro_MAIL_Sockets');
End;
Procedure MAIL.Free;
var
I, J: Integer;
Begin
For I := 0 To High(__Pro_Socket_Terminate_MAIL_Array) Do
Begin
If (__Pro_Socket_Terminate_MAIL_Array[I] = @self.__ssl_info) Then
Begin
For J := I To High(__Pro_Socket_Terminate_MAIL_Array) - 1 Do
__Pro_Socket_Terminate_MAIL_Array[J] := __Pro_Socket_Terminate_MAIL_Array[J + 1];
SetLength(__Pro_Socket_Terminate_MAIL_Array, High(__Pro_Socket_Terminate_MAIL_Array));
End;
End;
Pro_CloseSocket(@self.__ssl_info);
Pro_FreeSocket(@self.__ssl_info);
End;
Procedure MAIL.SetSubject(subject: String);
Begin
self.__Subject := subject;
End;
Procedure MAIL.SetMessage(message: String);
Begin
self.__Message := message;
End;
Procedure MAIL.SetFromName(from_name: String)
Begin
self.__FromName := from_name;
End;
Procedure MAIL.SetToName(to_name: String);
Begin
self.__ToName := to_name;
End;
Procedure MAIL.SetBufferSize(size: Integer);
Begin
If (size > 0) Then
self.__BufferSize := size;
End;
Procedure MAIL.SendMail;
var
Str: String;
Begin
If (self.__ssl_info.connected) Then
Begin
Str := 'EHLO ' + self.__Address + #13#10;
Pro_WriteSocket(@self.__ssl_info, Str, Length(Str));
self.__PrintSocket();
Str := 'AUTH LOGIN' + #13#10;
Pro_WriteSocket(@self.__ssl_info, Str, Length(Str));
self.__PrintSocket();
Pro_WriteSocket(@self.__ssl_info, self.__EncryptedUsername + #13#10, Length(self.__EncryptedUsername) + 2);
self.__PrintSocket();
Pro_WriteSocket(@self.__ssl_info, self.__EncryptedPassword + #13#10, Length(self.__EncryptedPassword) + 2);
self.__PrintSocket();
self.__PrintSocket();
Str := 'MAIL FROM: <' + self.__Username + '>' + #13#10;
Pro_WriteSocket(@self.__ssl_info, Str, Length(Str));
self.__PrintSocket();
Str := 'VRFY ' + self.__Username + #13#10;
Pro_WriteSocket(@self.__ssl_info, Str, Length(Str));
self.__PrintSocket();
Str := 'RCPT TO: <' + self.__Receiver + '>' + #13#10;
Pro_WriteSocket(@self.__ssl_info, Str, Length(Str));
self.__PrintSocket();
Pro_WriteSocket(@self.__ssl_info, 'DATA' + #13#10, 6);
self.__PrintSocket();
Str := 'From: ' + self.__FromName + '<' + self.__Username + '>' + #13#10;
Str := Str + 'To: ' + self.__ToName + '<' + self.__Receiver + '>' + #13#10;
Str := Str + 'Subject: ' + self.__Subject + #13#10#13#10;
Pro_WriteSocket(@self.__ssl_info, Str, Length(Str));
Pro_WriteSocket(@self.__ssl_info, self.__Message + #13#10 + '.' + #13#10, Length(self.__Message) + 5);
self.__PrintSocket();
Pro_WriteSocket(@self.__ssl_info, 'QUIT' + #13#10, 6);
self.__PrintSocket();
End;
End;
{$IFNDEF CODEINSIGHT}
Function HTTPS.__GetHost(Address: String): String;
var
I: Integer;
Begin
I := Pos('://', Address);
if (I >= 0) then
Address := Copy(Address, I + 3, Length(Address) - I);
I := Pos('/', Address);
if (I > 0) then
Address := Copy(Address, 0, I - 1);
Result := Address;
End;
Function HTTPS.__GetLocation(Address: String): String;
var
I: Integer;
Begin
I := Pos('://', Address);
if (I >= 0) then
Address := Copy(Address, I + 3, Length(Address) - I);
I := Pos('/', Address);
if (I > 0) then
Address := Copy(Address, I + 1, Length(Address) - I);
Result := Address;
End;
Function HTTPS.__RecvLine: String;
var
Line: String;
Character: Char;
Begin
While(True) Do
Begin
Pro_ReadSocket(@self.__ssl_info, @Character, 1);
If (Character = #13) Then
Begin
Pro_ReadSocket(@self.__ssl_info, @Character, 1);
If (Character = #10) Then Break;
Line := Line + #13;
End Else
If (Character = #10) Then Break;
Line := Line + Character;
End;
Result := Line;
End;
Function HTTPS.__RecvHeader: TStringArray;
var
I: Integer;
Line: String;
Begin
While(True) Do
Begin
Line := self.__RecvLine();
If (Length(Line) = 0) Then Exit;
SetLength(Result, Length(Result) + 1);
Result[I] := Line;
Inc(I);
End;
End;
Function HTTPS.__FindHeaderValue(LineToFind: String): String;
var
I, H, Position: Integer;
Begin
H := High(self.__Headers);
For I := 0 To H Do
Begin
Position := Pos(':', self.__Headers[I]);
If ((Position > 0) And (Copy(self.__Headers[I], 0, Position - 1) = LineToFind)) Then
Begin
Position := Pos(' ', self.__Headers[I]);
If (Position <> 0) Then
Begin
Result := Copy(self.__Headers[I], Position + 1, Length(self.__Headers[I]) - Position);
Exit;
End;
End;
End;
End;
Function HTTPS.__RecvChunkSize: Integer;
var
Line: String;
Position: Integer;
Function HexToInt(Hex : String): Integer;
var
Str : String;
Begin;
Str := '$' + Trim(Hex);
Result := StrToInt(Str);
If (Pos('-', Hex) > 0) Then
Result := -Result;
End;
Begin
Line := self.__RecvLine();
Position := Pos(';', Line);
If (Position <> 0) Then
Delete(Line, Position, 1);
Result := HexToInt(Line);
End;
Function HTTPS.__ReadChunked: String;
var
Encoding: String;
ChunkLength: Integer;
Buffer: String;
Bytes_Read: Integer;
Begin
SetLength(Buffer, self.__BufferSize);
__MemSet(@Buffer[1], 0, self.__BufferSize);
ChunkLength := 0;
Encoding := Lowercase(self.GetHeader('Transfer-Encoding'));
If (Encoding = 'chunked') Then
Begin
ChunkLength := self.__RecvChunkSize();
While(ChunkLength <> 0) Do
Begin
Bytes_Read := Pro_ReadSocket(@self.__ssl_info, @Buffer[1], ChunkLength);
Result := Result + Copy(Buffer, 0, Bytes_Read);
__MemSet(@Buffer[1], 0, self.__BufferSize);
self.__RecvLine();
ChunkLength := self.__RecvChunkSize();
End;
End Else
Begin
Encoding := self.GetHeader('Content-Length');
If (Length(Encoding) > 0) Then
Begin
ChunkLength := StrToIntDef(Encoding, -1);
If (ChunkLength > 0) Then
Begin
Bytes_Read := 0;
While(Bytes_Read < ChunkLength) Do
Begin
__MemSet(@Buffer[1], 0, self.__BufferSize);
Bytes_Read := Bytes_Read + Pro_ReadSocket(@self.__ssl_info, @Buffer[1], self.__BufferSize);
Result := Result + Copy(Buffer, 0, Bytes_Read);
If ((Bytes_Read >= ChunkLength) or (Bytes_Read = 0)) Then
Break;
End;
End;
End Else
Begin
While(True) Do
Begin
Bytes_Read := Pro_ReadSocket(@self.__ssl_info, @Buffer[1], self.__BufferSize);
If (Bytes_Read = 0) Then
Break;
Result := Result + Copy(Buffer, 0, Bytes_Read);
__MemSet(@Buffer[1], 0, self.__BufferSize);
End;
End;
End;
Result := Trim(Replace(Result, #0, '', [rfReplaceAll]));
End;
{$ENDIF}
Procedure HTTPS.Create(Address: String; Port: Word);
Begin
self.__Address := Address;
self.__ssl_info.port := Port;
self.__ssl_info.address := @self.__Address[1];
self.__ssl_info.socktype := SSLSocketType.SSL23_CLIENT_METHOD;
self.__BufferSize := 512;
Pro_CreateSocket(@self.__ssl_info);
Pro_ConnectSocket(@self.__ssl_info);
SetLength(__Pro_Socket_Terminate_HTTPS_Array, Length(__Pro_Socket_Terminate_HTTPS_Array) + 1);
__Pro_Socket_Terminate_HTTPS_Array[High(__Pro_Socket_Terminate_HTTPS_Array)] := @self.__ssl_info;
AddOnTerminate('__Destroy_Pro_HTTPS_Sockets');
End;
Procedure HTTPS.Free;
var
I, J: Integer;
Begin
For I := 0 To High(__Pro_Socket_Terminate_HTTPS_Array) Do
Begin
If (__Pro_Socket_Terminate_HTTPS_Array[I] = @self.__ssl_info) Then
Begin
For J := I To High(__Pro_Socket_Terminate_HTTPS_Array) - 1 Do
__Pro_Socket_Terminate_HTTPS_Array[J] := __Pro_Socket_Terminate_HTTPS_Array[J + 1];
SetLength(__Pro_Socket_Terminate_HTTPS_Array, High(__Pro_Socket_Terminate_HTTPS_Array));
End;
End;
Pro_FreeSocket(@self.__ssl_info);
Pro_CloseSocket(@self.__ssl_info);
End;
Procedure HTTPS.ClearParameters;
Begin
SetLength(self.__ParameterKeys, 0);
SetLength(self.__ParameterValues, 0);
End;
Function HTTPS.GetParameter(Parameter: String): String;
var
I: Integer;
Begin
For I := 0 To High(self.__ParameterKeys) Do
If (self.__ParameterKeys[I] = Lowercase(Parameter)) Then
Begin
Result := self.__ParameterValues[I];
Break;
End;
End;
Procedure HTTPS.SetParameter(Parameter, Value: String);
var
I, L: Integer;
Exists: Boolean;
Begin
Exists := False;
L := Length(__ParameterKeys);
For I := 0 To L - 1 Do
If (self.__ParameterKeys[I] = Lowercase(Parameter)) Then
Begin
self.__ParameterValues[I] := Lowercase(Parameter);
Exists := True;
Break;
End;
If (Not Exists) Then
Begin
SetLength(self.__ParameterKeys, L + 1);
SetLength(self.__ParameterValues, L + 1);
self.__ParameterKeys[L] := Lowercase(Parameter);
self.__ParameterValues[L] := Value;
End;
End;
Function HTTPS.GetHeader(Key: String): String;
Begin
If (Length(self.__Headers) <= 0) Then
self.__Headers := self.__RecvHeader();
Result := self.__FindHeaderValue(Key);
End;
Function HTTPS.CreateGetHeader: String;
var
I, J: Integer;
Generic_Keys: Array of String;
Generic_Values: Array of String;
Function KeyFound(this: ^HTTPS; Generic_Key: String): Boolean;
var
I: Integer;
Begin
Result := False;
For I := 0 To High(this^.__ParameterKeys) Do
Begin
If (this^.__ParameterKeys[I] = Lowercase(Generic_Key)) Then
Begin
Result := True;
Exit;
End;
End;
End;
Begin
Generic_Keys := ['Connection', 'User-Agent', 'Accept', 'Accept-Language', 'Accept-Charset', 'Cache-Control'];
Generic_Values := ['close', 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.97 Safari/537.11',
'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'en-US,en;q=0.8', 'ISO-8859-1,UTF-8;q=0.7,*;q=0.7',
'no-cache'];
Result := 'GET /' + self.__GetLocation(self.__Address) + ' HTTP/1.1' + #13#10;
Result := Result + 'Host: ' + self.__GetHost(self.__Address) + #13#10;
For I := 0 To High(Generic_Keys) Do
Begin
If (KeyFound(@self, Generic_Keys[I])) Then
Result := Result + self.__ParameterKeys[I] + ': ' + self.__ParameterValues[I] + #13#10
Else
Result := Result + Generic_Keys[I] + ': ' + Generic_Values[I] + #13#10;
End;
Result := Result + #13#10;
End;
Function HTTPS.GetPage: String;
var
Header: String;
Begin
Header := self.CreateGetHeader();
Pro_WriteSocket(@self.__ssl_info, Header, Length(Header));
Result := self.__ReadChunked;
End;
Function HTTPS.GetRawPage: String;
var
Header: String;
Buffer: String;
Bytes_Read: Integer;
Begin
Header := self.CreateGetHeader();
Pro_WriteSocket(@self.__ssl_info, Header, Length(Header));
self.__RecvHeader();
SetLength(Buffer, self.__BufferSize);
__MemSet(@Buffer[1], 0, self.__BufferSize);
While((Bytes_Read := Pro_ReadSocket(@self.__ssl_info, @Buffer[1], self.__BufferSize)) > 0) Do
Begin
Result := Result + Trim(Buffer);
__MemSet(@Buffer[1], 0, self.__BufferSize);
End;
Result := Trim(Replace(Result, #0, '', [rfReplaceAll]));
End;