Depois de muito pesquisar na Internet, não encontrei nenhum exemplo de SGip. Fiquei triste e finalmente fiz um exemplo de SGIP para Delphi6.0.
Contém um servidor e um cliente, o protocolo é compartilhado, o servidor é uma conexão longa sem bloqueio e o cliente é uma conexão curta bloqueadora.
O programa é muito confuso e o estilo é muito pobre. Espero que os especialistas possam me dar alguns conselhos.
([email protected],[email protected])
arquivo://cliente
unidade TestMain;
interface
usa
Windows, Mensagens, SysUtils, Variantes, Classes, Gráficos, Controles, Formulários,
Diálogos, ScktComp, StdCtrls, ExtCtrls, xy, Winsock;
const
FV_SNumber=3053112345;
FV_LoginPass='oi';
FV_LoginName='oi';
FV_SPNumber='12345';
T_Tel='13000000000';
FV_corpID='12345';
T_msg='Escrevi seu nome no céu e ele não foi levado pelo vento';
tipo
TForm1 = classe(TForm)
Memo1: TMemo;
Botão1: Botão T;
ClienteSocket1: TClientSocket;
Botão3: Botão T;
Botão4: Botão T;
Botão2: Botão T;
Botão5: Botão T;
Botão6: Botão T;
Botão7: Botão T;
ServidorSocket1: TServerSocket;
painel1: TPanel;
Procedimento Button2Click(Remetente: TObject);
procedimento Button1Click(Remetente: TObject);
procedimento Button6Click(Remetente: TObject);
procedimento Button5Click(Remetente: TObject);
procedimento Button3Click(Remetente: TObject);
procedimento Button4Click(Remetente: TObject);
procedimento ClientSocket1Read(Sender: TObject; Socket: TCustomWinSocket);
procedimento Button7Click(Remetente: TObject);
procedimento ServerSocket1ClientRead(Sender: TObject;
Soquete: TCustomWinSocket);
privado
{Declarações privadas}
público
{Declarações públicas}
arquivo://definição do protocolo cliente
sHead: SGIHead; arquivo://Definição do cabeçalho da mensagem
sBind: XBind; arquivo://Verificação de solicitação de conexão
sBind_Resp: Bind_Resp; arquivo://Resposta à verificação de solicitação de conexão
sSubmit: XSubmit; arquivo://SP->SMG enviar SMS
sSubmit_Resp: Submit_Resp; file://SMG responde ao status do SMS enviado pelo SP
sDeliver: XDeliver arquivo://SMG->SP enviar SMS
sDeliver_Resp: Deliver_Resp file://SP responde ao status do SMS enviado pelo SMG
sReport: XReport; arquivo://SMG->SP status anterior do SMS
sReport_Resp: Report_Resp; arquivo://Status de execução do comando de resposta
arquivo: // definição de protocolo do servidor
cHead: SGIHead; arquivo://Definição do cabeçalho da mensagem
cBind: XBind; arquivo://Verificação de solicitação de conexão
cBind_Resp: Bind_Resp; file://Resposta à verificação da solicitação de conexão
cSubmit: XSubmit; arquivo://SP->SMG enviar SMS
cSubmit_Resp: Submit_Resp file://SMG responde ao status do SMS enviado pelo SP
cDeliver: XDeliver; arquivo://SMG->SP enviar SMS
cDeliver_Resp: Deliver_Resp file://SP responde ao status do SMS enviado pelo SMG
cReport: XReport; arquivo://SMG->SP status anterior do SMS
cReport_Resp: Report_Resp arquivo://Status de execução do comando de resposta
fim;
var
Formulário1: TForm1;
implementação
{$R *.dfm}
procedimento TForm1.Button2Click(Remetente: TObject);
começar
ClienteSocket1.Active:=falso;
se ClientSocket1.Active então
memo1.Lines.Add('Falha no encerramento do cliente')
outro
memo1.Lines.Add('Cliente fechado com sucesso');
fim;
procedimento TForm1.Button1Click(Remetente: TObject);
começar
ClientSocket1.Active:=true;
se ClientSocket1.Active então
memo1.Lines.Add('Cliente aberto com sucesso')
outro
memo1.Lines.Add('Falha na abertura do cliente');
fim;
procedimento TForm1.Button6Click(Remetente: TObject);
começar
ServerSocket1.Active:=true;
se ServerSocket1.Active então
memo1.Lines.Add('Servidor aberto com sucesso')
outro
memo1.Lines.Add('Falha na abertura do servidor');
fim;
procedimento TForm1.Button5Click(Remetente: TObject);
começar
ServerSocket1.Active:=falso;
se ServerSocket1.Active então
memo1.Lines.Add('Falha no desligamento do servidor')
outro
memo1.Lines.Add('Servidor fechado com sucesso');
fim;
procedimento TForm1.Button3Click(Remetente: TObject);
var
FV_Data1_S,FV_Data2_S: string;
str_i,SendSize:inteiro;
stream1:TWinSocketStream;
abc,bc:palavra longa;
começar
stream1:=TWinSocketStream.Create(ClientSocket1.Socket,30000);
memo1.Lines.Add('-------------------Enviar solicitação BIND para o servidor------------------ --');
se não for ClientSocket1.Active então
começar
memo1.Lines.Add('O cliente não está aberto');
saída;
fim;
DateTimeToString(FV_Date1_S,'mmddhhnnss',agora);
DateTimeToString(FV_Date2_S,'zzz',agora);
FillChar(sBind,sizeof(sBind),0);
FillChar(sHead,sizeof(sHead),0);
str_i:=tamanho(sHead)+tamanho(sBind);
sBind.LonginType:=1;
strpcopy(sBind.LonginPass,FV_LoginPass);
strpcopy(sBind.LonginName,FV_LoginName);
abc:=htonl(FV_SNumber);
sHead.MessageLength:=htonl(str_i);
sHead.CommandId:=htonl(SGIP_Bind);
sHead.SNumber1:=abc;
sHead.SNumber2:=htonl(StrToInt(FV_Date1_S));
sHead.SNumber3:=htonl(StrToInt(FV_Date2_S));
stream1.WriteBuffer(sHead,sizeof(sHead));
stream1.WriteBuffer(sBind,sizeof(sBind));
memo1.Lines.Add('sHead.MessageLength '+inttostr(ntohl(sHead.MessageLength)));
memo1.Lines.Add('sHead.CommandId '+inttostr(ntohl(sHead.CommandId)));
bc:=ntohl(abc);
memo1.Lines.Add('sHead.SNumber1 '+inttostr(bc));
memo1.Lines.Add('sHead.SNumber2 '+inttostr(ntohl(sHead.SNumber2)));
memo1.Lines.Add('sHead.SNumber3 '+inttostr(ntohl(sHead.SNumber3)));
memo1.Lines.Add('sBind.LonginType '+inttostr(sBind.LonginType));
memo1.Lines.Add('sBind.LonginName '+sBind.LonginName);
memo1.Lines.Add('sBind.LonginPass '+sBind.LonginPass);
memo1.Lines.Add('------------------A solicitação de vinculação foi enviada-------------------- ------ -');
se stream1.WaitForData(5000) então
começar
fillchar(cHead,sizeof(cHead),0);
fillchar(cbind_resp,sizeof(cBind_Resp),0);
stream1.ReadBuffer(cHead,sizeof(cHead));
stream1.ReadBuffer(cBind_resp,sizeof(cBind_resp));
fim;
memo1.Lines.Add('cHead.MessageLength '+inttostr(ntohl(cHead.MessageLength)));
bc:=ntohl(cHead.CommandId);
memo1.Lines.Add('cHead.CommandId '+inttostr(bc));
bc:=ntohl(cHead.SNumber1);
memo1.Lines.Add('cHead.SNumber1 '+inttostr(bc));
memo1.Lines.Add('cHead.SNumber2 '+inttostr(ntohl(cHead.SNumber2)));
memo1.Lines.Add('cHead.SNumber3 '+inttostr(ntohl(cHead.SNumber3)));
memo1.Lines.Add('cBind.LonginType '+inttostr(cBind_resp.Result));
fluxo1.Free;
fim;
procedimento TForm1.Button4Click(Remetente: TObject);
arquivo://tipo
{abc=registro compactado
cabeça:SGIPHhead;
enviar:xEnviar;
fim;}
var
FV_Data1_S,FV_Data2_S: string;
eu,SendSize:inteiro;
arquivo://xxx:abc;
stream2:twinsocketstream;
abc,bc:palavra longa;
linha1, linha2: palavra longa;
começar
stream2:=twinsocketstream.Create(clientsocket1.Socket,5000);
TamanhoEnvio:=0;
memo1.Lines.Add('-------------------------enviar----------------- ---------');
se não for ClientSocket1.Active então
começar
memo1.Lines.Add('------------------O cliente não está aberto, falha no envio-------------');
saída;
fim;
DateTimeToString(FV_Date1_S,'mmddhhnnss',agora);
DateTimeToString(FV_Date2_S,'zzz',agora);
FillChar(sEnviar,tamanho(sEnviar),0);
FillChar(sHead,sizeof(sHead),0);
com ssubmit faça
começar
strpcopy(SPNúmero,'4488');//;
Número de cobrança :='8613188890924';
Contagem de usuários :=1 arquivo://1-100
{para i:=1 para UserCount faça
começar
file://strpcopy(UserNumber[i-1].TelN,'8613065073355');//+T_Tel);// :array de TelCount file://length é UserCount;
Número de usuário[i-1].TelN:='8613011725853';
fim;}
Número de usuário:='8613188890924';
CorpID:='41027';//CorpID:='4488';//strpcopy(CorpID,FV_corpID);
ServiceType:='4488';//FV_SPNumber);//'4488';
TaxaType :=1;
TaxaValor :='0';
DadoValor :='0';
AgenteFlag :=0;
MOrelatetoMTFlag :=2;
Prioridade :=0;
ExpireTime :='';
ScheduleTime :='';
ReportFlag :=1;
TP_pid :=0;
tp_udhi :=0;
Codificação da Mensagem :=15;
TipoDeMensagem :=0;
Comprimento da Mensagem :=htonl(161);
strpcopy(MessageContent,T_msg); arquivo://comprimento é MessageLength;
arquivo://Reserva :='';
fim;
{linha1:=sizeof(sHead);
linha2:=tamanho(sEnviar);}
com cabeça faça
começar
abc:=htonl(FV_SNumber);
Comprimento da mensagem:=htonl(sizeof(sHead)+sizeof(sSubmit)-3);
CommandId:=htonl(SGIP_Submit);
SNúmero1:=abc;
SNumber2:=htonl(StrToInt(FV_Date1_S));
SNumber3:=htonl(StrToInt(FV_Date2_S));
fim;
linha1:=stream2.Write(shead,sizeof(shead));
linha2:=stream2.Write(sSubmit,sizeof(sSubmit)-3);
se stream2.WaitForData(5000) então
começar
fillchar(cHead,sizeof(cHead),0);
fillchar(cSubmit_Resp,sizeof(cSubmit_Resp),0);
memo1.Lines.Add('ler enviar cabeçalho ............');
tentar
stream2.ReadBuffer(cHead,sizeof(cHead));
stream2.ReadBuffer(cSubmit_Resp,sizeof(cSubmit_Resp));
exceto
em e:exceção do
memo1.Lines.Add(e.Message);
fim;
memo1.Lines.Add('ler enviar csubmit_resp ............');
arquivo://stream2.ReadBuffer(cBind_Resp,sizeof(cBind_resp));
fim;
stream2.Free;
fim;
procedimento TForm1.ClientSocket1Read(Remetente: TObject;
Soquete: TCustomWinSocket);
var
comandoI,PackSize:Longword;
Recv1I,Recv2I:inteiro;
começar
FillChar(sHead,sizeof(sHead),0);
FillChar(sBind,sizeof(sBind),0);
Recv1I:=socket.ReceiveBuf(sHead,sizeof(sHead));
comandoI:=ntohl(sHead.CommandId);
PackSize:=ntohl(sHead.MessageLength);
se comandoI=SGIP_UNBIND_RESP então
começar
memo1.Lines.Add('------------------Solicitação SGIP_UNBIND_RESP recebida------------------');
saída;
fim;
Recv2I:=socket.ReceiveBuf(sBind,sizeof(sBind));
se comandoI=SGIP_BIND_RESP então
memo1.Lines.Add('---------------------SGIP_BIND_RESP------------------')
outro
se comandoI=SGIP_SUBMIT_RESP então
memo1.Lines.Add('---------------------SGIP_SUBMIT_RESP-------------')
outro
memo1.Lines.Add('---------------------'+inttostr(commandI)+'------------- - ---');
memo1.Lines.Add('MessageLength '+inttostr(ntohl(sHead.MessageLength)));
memo1.Lines.Add('CommandId '+inttostr(commandI));
memo1.Lines.Add('SNumber '+inttostr(ntohl(sHead.SNumber1))+' '+
inttostr(ntohl(sHead.SNumber2))+' '+inttostr(ntohl(sHead.SNumber3)));
memo1.Lines.Add('Result '+inttostr(sBind_Resp.Result));
memo1.Lines.add('------------------end SGIP_UNBIND_RESP-------------------');
fim;
procedimento TForm1.Button7Click(Remetente: TObject);
var
FV_Data1_S,FV_Data2_S: string;
stream3:TWinSocketStream;
começar
Stream3:=TWinSocketStream.Create(clientSocket1.Socket,5000);
memo1.Lines.Add('-------------------Enviar solicitação UnBIND para o servidor------------------ --');
se não for ClientSocket1.Active então
começar
memo1.Lines.Add('O cliente não está aberto');
stream3.free;
saída;
fim;
DateTimeToString(FV_Date1_S,'mmddhhnnss',agora);
DateTimeToString(FV_Date2_S,'zzz',agora);
FillChar(sHead,sizeof(sHead),0);
sHead.MessageLength:=htonl(sizeof(sHead));
sHead.CommandId:=htonl(SGIP_UNBIND);
sHead.SNumber1:=htonl(FV_SNumber);
sHead.SNumber2:=htonl(StrToInt(FV_Date1_S));
sHead.SNumber3:=htonl(StrToInt(FV_Date2_S));
stream3.Write(sHead,20);
FillChar(sHead,20,0);
se stream3.WaitForData(5000) então
começar
stream3.ReadBuffer(sHead,20);
fim;
stream3.Free;
fim;
procedimento TForm1.ServerSocket1ClientRead(Sender: TObject;
Soquete: TCustomWinSocket);
var
RecvSize1,RecvSize2,DeSize:inteiro;
comandoI,MessageSize:LongWord;
começar
RecvSize1:=0;
RecvSize2:=0;
FillChar(cHead,SizeOf(cHead),0);
RecvSize1:=socket.ReceiveBuf(cHead,SizeOf(cHead));
comandoI:=ntohl(cHead.CommandId);
MessageSize:=ntohl(cHead.MessageLength);
se comandoI=SGIP_BIND então
começar
memo1.Lines.Add('************************ Solicitação de vinculação recebida ***************** *****');
FillChar(cBind,SizeOf(cBind),0);
FillChar(cBind_Resp,SizeOf(cBind_Resp),0);
RecvSize2:=Socket.ReceiveBuf(cBind,MessageSize-RecvSize1);
if (RecvSize2+RecvSize1)<>MessageSize então
começar
memo1.Lines.Add('********************** erro de recebimento de dados de ligação ****************** ***** **');
saída;
fim;
RecvSize2:=0;RecvSize1:=0;
cHead.CommandId:=htonl(SGIP_BIND_RESP);
cHead.MessageLength:=htonl(sizeof(cHead)+sizeof(cBind_Resp));
cBind_Resp.Result:=0;
RecvSize1:=Socket.SendBuf(cHead,SizeOf(cHead));
RecvSize2:=Socket.SendBuf(cBind_Resp,SizeOf(cBind_Resp));
if (RecvSize1+RecvSize2)<>ntohl(cHead.MessageLength) então
começar
memo1.Lines.Add('************************Erro na resposta à solicitação de vinculação************* ***************');
saída;
fim;
fim
outro
se comandoI=SGIP_DELIVER então
começar
memo1.Lines.Add('************************Solicitação SGIP_DELIVER recebida****************** *********');
DeSize:=SizeOf(cEntregar);
FillChar(cDeliver,SizeOf(cDeliver),0);
FillChar(cDeliver_Resp,SizeOf(cDeliver_Resp),0);
RecvSize2:=Socket.ReceiveBuf(cDeliver,MessageSize-RecvSize1);
if (RecvSize2+RecvSize1)<>MessageSize então
começar
memo1.Lines.Add('************************Erro de recepção de dados SGIP_DELIVER*************** ******* **');
saída;
fim;
RecvSize2:=0;RecvSize1:=0;
cHead.CommandId:=htonl(SGIP_DELIVER_RESP);
cHead.MessageLength:=htonl(sizeof(cHead)+sizeof(cDeliver_Resp));
cDeliver_Resp.Result:=0;
RecvSize1:=Socket.SendBuf(cHead,SizeOf(cHead));
RecvSize2:=Socket.SendBuf(cDeliver_Resp,SizeOf(cDeliver_Resp));
if (RecvSize1+RecvSize2)<>ntohl(cHead.MessageLength) então
começar
memo1.Lines.Add('************************Resposta ao erro de solicitação SGIP_DELIVER**************** ****************');
saída;
fim;
fim
outro
se comandoI=SGIP_UNBIND então
começar
cHead.CommandId:=htonl(SGIP_UNBIND_RESP);
cHead.MessageLength:=htonl(sizeof(cHead));
memo1.Lines.Add('Resposta ao SGIP_UNBIND******************************');
RecvSize2:=Socket.SendBuf(cHead,sizeOf(cHead));
se RecvSize2<>ntohl(cHead.MessageLength) então
começar
memo1.Lines.Add('**********************SGIP_UNBIND enviando erro****************** ******');
saída;
fim;
fim
outro
começar
fim;
fim;
fim.
//................................................ ................ ............
arquivo://protocolo
unidade xy;
interface
usa
SysUtils;
const
SGIP_BIND =$1; arquivo://Verificar cliente
SGIP_BIND_RESP=$80000001; arquivo://servidor retorna solicitação de verificação
SGIP_UNBIND =$2; arquivo://desconectar
SGIP_UNBIND_RESP =$80000002; arquivo://Retornar ao status desconectado
SGIP_SUBMIT =$3; arquivo://Enviar mensagem curta MT para SMG
SGIP_SUBMIT_RESP =$80000003; arquivo://Retornar status de mensagem curta MT de envio SP
SGIP_DELIVER =$4; arquivo://SMG envia uma mensagem curta MO para SP
SGIP_DELIVER_RESP =$80000004; arquivo://retornar ao status SMG
SGIP_REPORT =$5; file://Envia o status atual de um comando de envio anterior para o SP
SGIP_REPORT_RESP=$80000005; arquivo://Status do SMG de resposta
file://Os seguintes protocolos são inúteis para SP
//SGIP_ADDSP=$6;
SGIP_ADDSP_RESP=$80000006;
SGIP_MODIFYSP =$7;
SGIP_MODIFYSP_RESP=$80000007;
//SGIP_DELETESP=$8;
SGIP_DELETESP_RESP=$80000008;
SGIP_QUERYROUTE=$9;
SGIP_QUERYROUTE_RESP=$80000009;
SGIP_ADDTELESEG=$a; //
SGIP_ADDTELESEG_RESP=$8000000a;
SGIP_MODIFYTELESEG=$b;
SGIP_MODIFYTELESEG_RESP=$8000000b;
SGIP_DELETETELESEG=$c; //
SGIP_DELETETELESEG_RESP=$8000000c;
SGIP_ADDSMG =$d;
SGIP_ADDSMG_RESP=$8000000d;
SGIP_MODIFYSMG=$e;
SGIP_MODIFYSMG_RESP=$0000000e;
SGIP_DELETESMG=$f;
SGIP_DELETESMG_RESP=$8000000f;
SGIP_CHECKUSER=$10;
SGIP_CHECKUSER_RESP=$80000010;
SGIP_USERRPT =$11;
SGIP_USERRPT_RESP=$80000011;
//SGIP_TRACE =$1000;
SGIP_TRACE_RESP=$80001000;
tipo
TEMPTY=Arquivo de registro://registro vazio
fim;
arquivo://cabeçalho da mensagem
SGIPHhead=Registro
MessageLength:longword; file://O comprimento total da mensagem (bytes)
CommandId: palavra longa; arquivo://commandID
SNumber1, SNumber2, SNumber3: arquivo longo: // número de série
fim;
arquivo://corpo da mensagem
XBind=Registro //
LonginType :byte;
LonginPass :array[0..15] de char;
LonginName :array[0..15] de char;
Reserva :array[0..7] de char;
fim;
Bind_Resp=Registro
Resultado: byte;
Reserva :array[0..7] de char;
fim;
//
Desvincular=TEMPTY;
Desvincular_Resp=TEMPTY;
//
TelCount=arquivo de registro://número do celular
TelN :array[0..20] de char;
fim;
XSubmit=Registro
SPNumber: array[0..20] de char;
ChargeNumber :array[0..20] de char;
Contagem de usuários: byte; arquivo://1-100
UserNumber :array[0..20] of char;//TelCount; file://length é UserCount
CorpID: array[0..4] de char;
ServiceType :array[0..9] de char;
FeeType :byte;
FeeValue :array[0..5] de char;
DadoValor :array[0..5] de char;
AgentFlag :byte;
MOrelatetoMTFlag :byte;
Prioridade:byte;
ExpireTime: array[0..15] de char;
ScheduleTime :array[0..15] de char;
ReportFlag :byte;
TP_pid:byte;
TP_udhi:byte;
Codificação da mensagem:byte;
MessageType: byte;
Comprimento da mensagem: palavra longa;
MessageContent :array[0..160] de char file://length é MessageLength;
Reserva :array[0..7] de char;
fim;
Submit_Resp=Registro
Resultado: byte;
Reserva :array[0..7] de char;
fim;
//
XDeliver=Registro
UserNumber :array[0..20] de char;
SPNumber: array[0..27] de char;
{TP_pid: byte;
TP_udhi:byte;
Codificação da mensagem:byte;
Comprimento da mensagem: palavra longa;}
MessageContent :array[0..254] de char file://length é MessageLength;
Reservador :array[0..7] de char;
fim;
Deliver_Resp=Registro
Resultado: byte;
Reserva :array[0..7] de char;
fim;
//
XReport=Registro
SubSequNumber1, SubSequNumber2, SubSequNumber3: palavra longa;
ReportType: byte;
UserNumber :array[0..20] de char;
Estado: byte;
Código de erro:byte;
Reserva :array[0..7] de char;
fim;
Report_Resp=Registro
Resultado: byte;
Reserva :array[0..7] de char;
fim;
implementação
fim.
arquivo://,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,//
Servidor
unidade principal;
interface
usa
Windows, Mensagens, SysUtils, Variantes, Classes, Gráficos, Controles, Formulários,
Diálogos, xy, ScktComp, StdCtrls, Winsock;
tipo
TForm1 = classe(TForm)
Memo1: TMemo;
ServidorSocket1: TServerSocket;
procedimento ServerSocket1ClientRead(Sender: TObject;
Soquete: TCustomWinSocket);
procedimento ServerSocket1ClientError(Remetente: TObject;
Soquete: TCustomWinSocket; ErrorEvent: TErrorEvent;
varErrorCode: Inteiro);
privado
{Declarações privadas}
público
{Declarações públicas}
fim;
var
Formulário1: TForm1;
implementação
{$R *.dfm}
procedimento TForm1.ServerSocket1ClientRead(Sender: TObject;
Soquete: TCustomWinSocket);
tipo
SendPack = registro compactado
chefe: SGIHead;
resp: Bind_Resp;
fim;
var
ReHead:SGIPHead;
sresp:Bind_Resp;
Revincular:xBind;
ReEntregar:XDeliver;
RelatórioRelatório:XRelatório;
i1,i2:inteiro;
string:string;
S_Número1,S_Número2,S_Número3,longI1:palavra longa;
s_Pack:EnviarPack;
começar
fillchar(sresp,sizeof(sresp),0);
fillchar(ReHead,sizeof(ReHead),0);
i1:=Socket.ReceiveBuf(ReHead,sizeof(ReHead));
se i1<>sizeof(ReHead) então
começar
memo1.Lines.Add('Saída de erro de mensagem recebida');
saída;
fim;
S_Number1:=ReHead.SNumber1;
S_Number2:=ReHead.SNumber2;
S_Number3:=ReHead.SNumber3;
ReHead.MessageLength:=ntohl(ReHead.MessageLength);
ReHead.CommandId:=ntohl(ReHead.CommandId);
ReHead.SNumber1:=ntohl(ReHead.SNumber1);
ReHead.SNumber2:=ntohl(ReHead.SNumber2);
ReHead.SNumber3:=ntohl(ReHead.SNumber3);
memo1.Lines.Add('ler mensagem SMG');
memo1.Lines.Add(inttostr(ReHead.MessageLength));
memo1.Lines.Add(inttostr(ReHead.CommandId));
memo1.Lines.Add(inttostr(ReHead.SNumber1));
memo1.Lines.Add(inttostr(ReHead.SNumber2));
memo1.Lines.Add(inttostr(ReHead.SNumber3));
se ReHead.CommandId=SGIP_UNBIND então
começar arquivo://desconectar
FillChar(ReHead,SizeOf(ReHead),0);
ReHead.MessageLength:=htonl(SizeOf(ReHead));
ReHead.CommandId:=htonl(SGIP_UNBIND_RESP);
ReHead.SNumber1:=S_Number1;
ReHead.SNumber2:=S_Number2;
ReHead.SNumber3:=S_Number3;
i1:=socket.SendBuf(ReHead,sizeof(ReHead));
se i1<>sizeof(ReHead) então
memo1.Lines.Add('Enviar erro SGIP_UNBIND_Resp')
outro
memo1.Lines.Add('Enviar SGIP_UNBIND_Resp OK');
fim
senão se ReHead.CommandId=SGIP_BIND então
começar arquivo://SMG envia uma mensagem curta MO para SP
FillChar(s_Pack,SizeOf(s_Pack),0);
FillChar(ReBind,SizeOf(ReBind),0);
socket.ReceiveBuf(ReBind,SizeOf(ReBind));
s_Pack.head.MessageLength:=htonl(SizeOf(s_Pack));
s_Pack.head.CommandId:=htonl(SGIP_BIND_RESP);
s_Pack.head.SNumber1:=S_Number1;
s_Pack.head.SNumber2:=S_Number2;
s_Pack.head.SNumber3:=S_Number3;
s_Pack.resp.Result:=0;
i1:=socket.SendBuf(s_Pack,SizeOf(s_Pack));
se i1<>SizeOf(s_Pack) então
memo1.Lines.Add('enviar erro SGIP_Bind_Resp')
outro
memo1.Lines.Add('Enviar SGIP_bind_Resp');
fim
senão se ReHead.CommandId = SGIP_DELIVER então
começar
FillChar(s_Pack,SizeOf(s_Pack),0);
FillChar(ReDeliver,SizeOf(ReDeliver),0);
Socket.ReceiveBuf(ReDeliver,SizeOf(ReDeliver));
s_Pack.head.MessageLength:=htonl(SizeOf(s_Pack));
s_Pack.head.CommandId:=htonl(SGIP_DELIVER_RESP);
s_Pack.head.SNumber1:=S_Number1;
s_Pack.head.SNumber2:=S_Number2;
s_Pack.head.SNumber3:=S_Number3;
s_Pack.resp.Result:=0;
se socket.SendBuf(s_Pack,SizeOf(s_Pack)) <>SizeOf(s_Pack) então
memo1.Lines.Add('enviar erro SGIP_DELIVER_RESP')
outro
memo1.Lines.Add('Enviar SGIP_DELIVER_RESP OK');
memo1.Lines.Add(ReDeliver.UserNumber);
memo1.Lines.Add(ReDeliver.SPNumber);
arquivo://longI1:=ntohl(ReDeliver.MessageLength);
arquivo://memo1.Lines.Add(inttostr(longI1)+' '+inttostr(ReDeliver.MessageLength));
memo1.Lines.Add(ReDeliver.MessageContent);
fim
senão se ReHead.CommandId = SGIP_REPORT então
começar
FillChar(s_Pack,SizeOf(s_Pack),0);
FillChar(ReRelatório,SizeOf(ReRelatório),0);
Socket.ReceiveBuf(ReReport,SizeOf(ReReport));
s_Pack.head.MessageLength:=htonl(SizeOf(s_Pack));
s_Pack.head.CommandId:=htonl(SGIP_REPORT_RESP);
s_Pack.head.SNumber1:=S_Number1;
s_Pack.head.SNumber2:=S_Number2;
s_Pack.head.SNumber3:=S_Number3;
s_Pack.resp.Result:=0;
se socket.SendBuf(s_Pack,SizeOf(s_Pack)) <>SizeOf(s_Pack) então
memo1.Lines.Add('enviar erro SGIP_Bind_Resp')
outro
memo1.Lines.Add('Enviar SGIP_bind_Resp');
memo1.Lines.Add(ReReport.UserNumber);
memo1.Lines.Add(inttostr(ReReport.State));
fim;
fim;
procedimento TForm1.ServerSocket1ClientError(Sender: TObject;
Soquete: TCustomWinSocket; ErrorEvent: TErrorEvent;
varErrorCode: Inteiro);
var
mensagem de erro:string;
começar
caso ErroEvento de
eeGeral: mensagem de erro:='eeGeral';
eeSend: mensagem de erro:='eeSend';
eeReceive: mensagem de erro:='eeReceive';
eeConnect: mensagem de erro:='eeConnect';
eeDisconnect: mensagem de erro:='eeDisconnect';
eeAccept: mensagem de erro:='eeAccept';
fim;
Código de erro:=0;
Memo1.Lines.Add('Erro de soquete:'+errorMsg);
fim;
fim.