/*
*----------------------------------------------------------------------
*
* WriteCloseRecords --
*
* Writes an EOF record for the stream content if necessary.
* If this is the last writer to close, writes an FCGI_END_REQUEST
* record.
*
*----------------------------------------------------------------------
*/
static void WriteCloseRecords(struct FCGX_Stream *stream)
{
FCGX_Stream_Data *data = (FCGX_Stream_Data *) stream->data;
/*
* Enter rawWrite mode so final records won't be encapsulated as
* stream data.
*/
data->rawWrite = TRUE;
/*
* Generate EOF for stream content if needed.
*/
if (!(data->type == FCGI_STDERR
&& stream->wrNext == data->buff
&& !data->isAnythingWritten)) {
FCGI_Header header;
header = MakeHeader(data->type, data->reqDataPtr->requestId, 0,
0);
FCGX_PutStr((char *)&header, sizeof(header), stream);
};
/*
* Generate FCGI_END_REQUEST record if needed.
*/
if (data->reqDataPtr->nWriters == 1) {
FCGI_EndRequestRecord endRequestRecord;
endRequestRecord.header = MakeHeader(FCGI_END_REQUEST,
data->reqDataPtr->requestId,
sizeof(endRequestRecord.body), 0);
endRequestRecord.body =
MakeEndRequestBody(data->reqDataPtr->appStatus,
FCGI_REQUEST_COMPLETE);
FCGX_PutStr((char *)&endRequestRecord, sizeof(endRequestRecord),
stream);
}
data->reqDataPtr->nWriters--;
}
void ProcessaCMD_HELLO( BYTE * buffer ){
BYTE bufOut[8];
BYTE bLog;
DWORD dwSerNum;
char i;
if ( ModemGSM_IsReady() == FALSE ){
//enviaNACK( buffer[ EO_FIELD ], DONT_CONNECTED );
return;
}
bLog = EVT_SW_HELLO;
Log( EVT_SW, &bLog, sizeof( BYTE ));
dwSerNum = GetSerialNumber();
// altera o estado do SMS Box para conectado com o Host
SetStatus( ST_COM_PC_OK );
#ifdef USE_SONDA
// timer para controle de conexão do host
serialPC_SondaTimer = GetTimer( SONDA_TIMEOUT );
#endif
MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_HELLO );
for ( i = sizeof( DWORD ) ; i ; i-- )
{
bufOut[ CMD_FIELD + (sizeof(DWORD) - (i - 1)) ] = ((BYTE*)&dwSerNum)[(i - 1)];
}
enviarPacotePC( bufOut, sizeof( bufOut ));
}
void ProcessaCMD_GET_DEV_ST( BYTE * buffer ){
BYTE bufOut[6];
BYTE bState;
BYTE bRet;
BYTE bDevID;
BYTE bLog;
if ( !IsConnected() ){
return;
}
bLog = EVT_SW_DEV_ST;
Log( EVT_SW, &bLog, sizeof( BYTE ));
bDevID = buffer[ CMD_FIELD + 1 ];
bRet = Dev_GetStatus( bDevID , &bState );
if ( bRet == NULL ){
bState = DEV_SET_STATE_ERROR;
}
MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_GET_DEV_ST );
bufOut[ CMD_FIELD + 1 ] = bDevID;
bufOut[ CMD_FIELD + 2 ] = bState;
enviarPacotePC( bufOut, sizeof( bufOut ));
}
void ProcessaCMD_VERSION( BYTE * buffer )
{
BYTE bufOut[16];
BYTE bLog;
DWORD* dwTmp[3];
BYTE bTmp;
char i;
if ( !IsConnected() )
{
return;
}
bLog = EVT_SW_VERSION;
Log( EVT_SW, &bLog, sizeof( BYTE ));
MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_VERSION );
dwTmp[0] = GetBoardVersion();
dwTmp[1] = GetFirmwareVersion();
dwTmp[2] = GetBootLoaderVersion();
for ( bLog = 0; bLog < GET_VEC_NUM_MEMBERS(dwTmp); bLog++ )
{
for ( i = sizeof( DWORD ) ; i ; i-- )
{
bTmp = CMD_FIELD + (bLog << 2) + (sizeof(DWORD) - (i - 1));
bufOut[ bTmp ] = ((BYTE*)dwTmp[bLog])[(i - 1)];
}
}
enviarPacotePC( bufOut, sizeof( bufOut ));
}
void ProcessaCMD_SET_DEV_ST( BYTE * buffer ){
BYTE bufOut[6];
BYTE bRet;
BYTE bNewState;
BYTE bDevID;
if ( !IsConnected() ){
return;
}
bDevID = EVT_SW_DEV_ST;
Log( EVT_SW, &bDevID, sizeof( BYTE ));
bDevID = buffer[ CMD_FIELD + 1 ];
bNewState = buffer[ CMD_FIELD + 2 ];
bRet = Dev_ChangeState( bDevID , bNewState );
if ( bRet != TRUE ){
bNewState = DEV_SET_STATE_ERROR;
}
MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_SET_DEV_ST );
bufOut[ CMD_FIELD + 1 ] = bDevID;
bufOut[ CMD_FIELD + 2 ] = bNewState;
enviarPacotePC( bufOut, sizeof( bufOut ));
}
void ProcessaCMD_BOOTLOADER_UPLOAD_FW( BYTE * buffer ){
BYTE bufOut[5];
BYTE bLen;
if ( !IsConnected()){
return;
}
serialPC_ContPackages++;
//enviaACK( buffer[EO_FIELD] );
bLen = buffer[LEN_FIELD]-1; // retirado do comprimento o equivalente ao campo CMD
MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_BOOTLOADER_UPLOAD_FW );
if ( bLen > (BOOT_LOADER_FRAME_LEN + sizeof( DWORD )) ){
bufOut[CMD_FIELD+1] = BOOT_LOADER_FLASH_FRAME_TOO_LONG;
}
else{
bufOut[CMD_FIELD+1] = UpLoad2Flash( (BYTE*)&buffer[CMD_FIELD+1], bLen );
//bufOut[CMD_FIELD+1] = 1;
}
enviarPacotePC( bufOut, sizeof( bufOut ));
serialPC_ContPackages--;
return;
}
j_result_t CXSdk::SearchRecord(j_int32_t nUserID, const j_char_t *pResid, j_time_t begin, j_time_t end, RcdTimeList &timeList)
{
if (m_usrMap[nUserID].is_active)
{
J_CtrlPacket *pCtrlData = (J_CtrlPacket *)new char[sizeof(J_CtrlHead) + sizeof(J_RecordData)];
MakeHeader((char *)pCtrlData, m_usrMap[nUserID].id.usr_id, jo_rcd_search_req, jo_intact_pack, 0, sizeof(J_RecordData));
J_RecordData *rcdCtrlData = (J_RecordData *)pCtrlData->data;
memset(pCtrlData->data, 0, sizeof(J_RecordData));
memcpy(rcdCtrlData->res_id, pResid, strlen(pResid));
rcdCtrlData->begin_time = begin;
rcdCtrlData->end_time = end;
m_sockMap[nUserID]->Write(pCtrlData, sizeof(J_CtrlHead) + sizeof(J_RecordData));
J_CtrlHead ctrl_head_resp = {0};
m_sockMap[nUserID]->Read(&ctrl_head_resp, sizeof(J_CtrlHead));
if (ctrl_head_resp.ret == 0)
{
//数据解析
int nTotleLen = ctrl_head_resp.ex_length;
RcdTimeInfo *pInfo = NULL;
pInfo = (RcdTimeInfo *)new char[nTotleLen];
m_sockMap[nUserID]->Read(pInfo, nTotleLen);
while (nTotleLen > 0)
{
timeList.push_back(pInfo);
++pInfo;
nTotleLen -= sizeof(RcdTimeInfo);
}
}
}
return 0;
}
void enviaNACK( BYTE dest, BYTE errCode ){
BYTE buffer[5];
MakeHeader( buffer, sizeof( buffer ), dest, NACK );
buffer[ CMD_FIELD+1 ] = errCode;
enviarPacotePC( buffer, sizeof( buffer ));
}
int main (int argc,char **argv) {
char dummy[256];
char *tif_data;
uint32 data_size;
uint32 offset;
uint16 dir_count;
TIFFDirEntry tdir;
_mkdir(OUTPUTDIR);
memset(dummy, 0x41, sizeof(dummy));
data_size = sizeof(TIFFHeader)+sizeof(dummy)+sizeof(uint16)+(2*NSIZE(ttags)+4)*sizeof(TIFFDirEntry);
printf("\n*** TIF file format fuzzer ***\n");
tif_data = (char*)malloc(data_size);
if (!tif_data) {
printf("error: cannot malloc\n");
return -1;
}
memset(tif_data, 0x00, data_size);
offset = sizeof(TIFFHeader);
MakeHeader(tif_data, sizeof(TIFFHeader)+sizeof(dummy));
memcpy(tif_data+offset, dummy, sizeof(dummy));
offset += sizeof(dummy);
dir_count = 3;
memcpy(tif_data+offset, &dir_count, sizeof(uint16));
offset += sizeof(uint16);
tdir.tdir_tag = 0x100;
tdir.tdir_type = TIFF_SHORT;
tdir.tdir_count = 1;
tdir.tdir_offset = 600;
memcpy(tif_data+offset, &tdir, sizeof(TIFFDirEntry));
offset += sizeof(TIFFDirEntry);
tdir.tdir_tag = 0x101;
tdir.tdir_type = TIFF_SHORT;
tdir.tdir_count = 1;
tdir.tdir_offset = 400;
memcpy(tif_data+offset, &tdir, sizeof(TIFFDirEntry));
offset += sizeof(TIFFDirEntry);
DirFuzz(tif_data, data_size, offset);
free(tif_data);
getch();
return 0;
}
//______________________________________________________________________________
void HtmlSummary::Build()
{
// Build the summary.
MakeHeader();
for (int i=0;i<fNTables;i++) {
GetTable(i)->Build();
fHtml += GetTable(i)->Html();
}
MakeFooter();
}
void ProcessaCMD_BOOTLOADER_CHANGEFW( BYTE * buffer ){
BYTE bufOut[5];
if ( !IsConnected( ) ){
return;
}
MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_BOOTLOADER_CHANGEFW );
bufOut[CMD_FIELD+1 ] = StartChangeFirmware();
enviarPacotePC( bufOut, sizeof( bufOut ));
}
static void WebServerReadHandler(void)
{
int count;
assert(fromWS.next == fromWS.stop);
assert(fromWS.next == &fromWS.buff[0]);
count = read(STDIN_FILENO, fromWS.next + sizeof(FCGI_Header),
BUFFLEN - sizeof(FCGI_Header));
if(count < 0) {
exit(errno);
}
*((FCGI_Header *) &fromWS.buff[0])
= MakeHeader(FCGI_STDIN, requestId, count, 0);
fromWS.stop = &fromWS.buff[sizeof(FCGI_Header) + count];
webServerReadHandlerEOF = (count == 0);
}
bool NewSendCGITask::Req2Buf(uint32_t _taskid, void* const _user_context, AutoBuffer& _outbuffer, AutoBuffer& _extend, int& _error_code, const int _channel_select)
{
string reqProtobuf = MakeMsgReq();
DWORD dwCompressed = 0;
string body = nocompress_aes(pAuthInfo->m_Session, reqProtobuf);
if (!body.size()) return FALSE;
string header = MakeHeader(BaseHeader::s_cookie, m_nCgiType, reqProtobuf.size(), reqProtobuf.size());
string req = header + body;
_outbuffer.AllocWrite(req.size());
_outbuffer.Write(req.c_str(), req.size());
return TRUE;
}
/*
*----------------------------------------------------------------------
*
* EmptyBuffProc --
*
* Encapsulates any buffered stream content in a FastCGI
* record. Writes the data, making the buffer empty.
*
*----------------------------------------------------------------------
*/
static void EmptyBuffProc(struct FCGX_Stream *stream, int doClose)
{
FCGX_Stream_Data *data = (FCGX_Stream_Data *) stream->data;
int cLen, eLen;
/*
* If the buffer contains stream data, fill in the header.
* Pad the record to a multiple of 8 bytes in length. Padding
* can't overflow the buffer because the buffer is a multiple
* of 8 bytes in length. If the buffer contains no stream
* data, reclaim the space reserved for the header.
*/
if (!data->rawWrite) {
cLen = stream->wrNext - data->buff - sizeof(FCGI_Header);
if (cLen > 0) {
eLen = AlignInt8(cLen);
/*
* Giving the padding a well-defined value keeps Purify happy.
*/
memset(stream->wrNext, 0, eLen - cLen);
stream->wrNext += eLen - cLen;
*((FCGI_Header *) data->buff)
= MakeHeader(data->type,
data->reqDataPtr->requestId, cLen, eLen - cLen);
} else {
stream->wrNext = data->buff;
}
}
if (doClose) {
WriteCloseRecords(stream);
};
if (stream->wrNext != data->buff) {
data->isAnythingWritten = TRUE;
if (write_it_all(data->reqDataPtr->ipcFd, (char *)data->buff,
stream->wrNext - data->buff) < 0) {
SetError(stream, OS_Errno);
return;
}
stream->wrNext = data->buff;
}
/*
* The buffer is empty.
*/
if (!data->rawWrite) {
stream->wrNext += sizeof(FCGI_Header);
}
}
int CXSdk::Login(const j_char_t *pAddr, j_int16_t nPort, const j_char_t *pUsername, const j_char_t *pPassword)
{
//int nRet = sizeof(J_CtrlHead);
J_CtrlPacket *pCtrlData = (J_CtrlPacket *)new j_char_t[sizeof(J_CtrlHead)+sizeof(J_LoginData)];
MakeHeader((j_char_t *)pCtrlData, NULL, jo_login_req, jo_intact_pack, 0, sizeof(J_LoginData));
J_LoginData *loginData = (J_LoginData *)pCtrlData->data;
memset(pCtrlData->data, 0, sizeof(J_LoginData));
memcpy(loginData->user_name, pUsername, strlen(pUsername));
memcpy(loginData->pass_word, pPassword, strlen(pPassword));
wxSocketClient *pSocket = new wxSocketClient();
int sdkId = 0;
wxIPV4address addr;
addr.Hostname(wxString::FromUTF8(pAddr));
addr.Service(nPort);
if (pSocket->Connect(addr))
{
pSocket->Write(pCtrlData, sizeof(J_CtrlHead)+sizeof(J_LoginData));
J_CtrlHead ctrl_head = {0};
pSocket->Read(&ctrl_head, sizeof(J_CtrlHead));
if (ctrl_head.ret == 0)
{
sdkId = GetIdleUser();
if (sdkId > 0)
{
memcpy(m_usrMap[sdkId].ip_addr, pAddr, strlen(pAddr));
m_usrMap[sdkId].port = nPort;
m_usrMap[sdkId].is_active = true;
memcpy(m_usrMap[sdkId].user_name, pUsername, strlen(pUsername));
memcpy(m_usrMap[sdkId].pass_word, pPassword, strlen(pPassword));
memcpy(m_usrMap[sdkId].id.usr_id, ctrl_head.user_id, sizeof(ctrl_head.user_id));
m_sockMap[sdkId] = pSocket;
}
}
}
else
{
delete pSocket;
}
delete pCtrlData;
return sdkId;
}
void ProcessaCMD_SONDA( BYTE * buffer ){
#ifdef USE_SONDA
BYTE bufOut[4];
BYTE bLog;
if ( !IsConnected() ){
return;
}
bLog = EVT_SW_SONDA;
Log( EVT_SW, &bLog, sizeof( BYTE ));
RestartTimer( serialPC_SondaTimer, SONDA_TIMEOUT );
MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_SONDA );
enviarPacotePC( bufOut, sizeof( bufOut ));
#endif
}
void CXSdk::Logout(int nUserID)
{
if (m_usrMap[nUserID].is_active)
{
J_CtrlHead ctrl_head_req = {0};
MakeHeader((char *)&ctrl_head_req, m_usrMap[nUserID].id.usr_id, jo_logout_req, jo_intact_pack, 0, sizeof(J_LoginData));
m_sockMap[nUserID]->Write(&ctrl_head_req, sizeof(J_CtrlHead));
J_CtrlHead ctrl_head_resp = {0};
m_sockMap[nUserID]->Read(&ctrl_head_resp, sizeof(J_CtrlHead));
if (ctrl_head_resp.ret == 0)
{
memset(&m_usrMap[nUserID], 0, sizeof(J_UserInfo));
m_sockMap[nUserID]->Close();
delete m_sockMap[nUserID];
m_sockMap.erase(nUserID);
PutIdleUser(nUserID);
}
}
}
void ProcessaCMD_BOOTLOADER_GETCRC32( BYTE * buffer ){
BYTE bufOut[8];
DWORD crc32;
if ( !IsConnected( ) ){
return;
}
MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_BOOTLOADER_GETCRC32 );
crc32 = GetCalcCRC32();
ResetCRC32( );
bufOut[CMD_FIELD + 1] = HIBYTE( HIWORD( crc32 ) );
bufOut[CMD_FIELD + 2] = LOBYTE( HIWORD( crc32 ) );
bufOut[CMD_FIELD + 3] = HIBYTE( LOWORD( crc32 ) );
bufOut[CMD_FIELD + 4] = LOBYTE( LOWORD( crc32 ) );
enviarPacotePC( bufOut, sizeof( bufOut ));
}
void ProcessaCMD_ASC( BYTE * buffer ){
BYTE bRet;
BYTE bufOut[5];
BYTE bLog[2];
if ( !IsConnected() ){
return;
}
bLog[0] = EVT_SW_ASC;
bLog[1] = buffer[CMD_FIELD+1];
Log( EVT_SW, bLog, 2 * sizeof( BYTE ));
MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_ASC );
bRet = ModemGSM_ChangeCard( buffer[CMD_FIELD+1]);
bufOut[CMD_FIELD+1] = (bRet == TRUE)? 0 : 1;
enviarPacotePC( bufOut, sizeof( bufOut ) );
}
void ProcessaCMD_STATUS( BYTE * buffer ){
BYTE bufOut[6];
WORD wStatus;
BYTE bLog;
if ( !IsConnected() ){
return;
}
bLog = EVT_SW_STATUS;
Log( EVT_SW, &bLog, sizeof( BYTE ));
wStatus = GetStatus();
MakeHeader( bufOut, sizeof( bufOut ), buffer[EO_FIELD], CMD_STATUS );
bufOut[ CMD_FIELD + 1 ] = HIBYTE( wStatus );
bufOut[ CMD_FIELD + 2 ] = LOBYTE( wStatus );
enviarPacotePC( bufOut, sizeof( bufOut ));
}
/*
*----------------------------------------------------------------------
*
* ProcessBeginRecord --
*
* Reads an FCGI_BEGIN_REQUEST record.
*
* Results:
* BEGIN_RECORD for normal return. FCGX_PROTOCOL_ERROR for
* protocol error. SKIP for attempt to multiplex
* connection. -1 for error from write (errno in stream).
*
* Side effects:
* In case of BEGIN_RECORD return, stores requestId, role,
* keepConnection values, and sets isBeginProcessed = TRUE.
*
*----------------------------------------------------------------------
*/
static int ProcessBeginRecord(int requestId, FCGX_Stream * stream)
{
FCGX_Stream_Data *data = (FCGX_Stream_Data *) stream->data;
FCGI_BeginRequestBody body;
if (requestId == 0 || data->contentLen != sizeof(body)) {
return FCGX_PROTOCOL_ERROR;
}
if (data->reqDataPtr->isBeginProcessed) {
/*
* The Web server is multiplexing the connection. This library
* doesn't know how to handle multiplexing, so respond with
* FCGI_END_REQUEST{protocolStatus = FCGI_CANT_MPX_CONN}
*/
FCGI_EndRequestRecord endRequestRecord;
endRequestRecord.header = MakeHeader(FCGI_END_REQUEST,
requestId, sizeof(endRequestRecord.body), 0);
endRequestRecord.body
= MakeEndRequestBody(0, FCGI_CANT_MPX_CONN);
if (write_it_all(data->reqDataPtr->ipcFd,
(char *)&endRequestRecord,
sizeof(endRequestRecord)) < 0) {
SetError(stream, OS_Errno);
return -1;
}
return SKIP;
}
/*
* Accept this new request. Read the record body.
*/
data->reqDataPtr->requestId = requestId;
if (FCGX_GetStr((char *)&body, sizeof(body), stream)
!= sizeof(body)) {
return FCGX_PROTOCOL_ERROR;
}
data->reqDataPtr->keepConnection = (body.flags & FCGI_KEEP_CONN);
data->reqDataPtr->role = (body.roleB1 << 8) + body.roleB0;
data->reqDataPtr->isBeginProcessed = TRUE;
return BEGIN_RECORD;
}
int CXSdk::PtzControl(int nUserID, const char *pResid, int nCmd, int nParam)
{
if (m_usrMap[nUserID].is_active)
{
J_CtrlPacket *pCtrlData = (J_CtrlPacket *)new char[sizeof(J_CtrlHead) + sizeof(J_PTZCtlData)];
MakeHeader((char *)pCtrlData, m_usrMap[nUserID].id.usr_id, jo_ptz_control_req, jo_intact_pack, 0, sizeof(J_PTZCtlData));
J_PTZCtlData *ptzCtrlData = (J_PTZCtlData *)pCtrlData->data;
memset(pCtrlData->data, 0, sizeof(J_PTZCtlData));
memcpy(ptzCtrlData->res_id, pResid, strlen(pResid));
ptzCtrlData->command = nCmd;
ptzCtrlData->param = nParam;
m_sockMap[nUserID]->Write(pCtrlData, sizeof(J_CtrlHead) + sizeof(J_PTZCtlData));
J_CtrlHead ctrl_head_resp = {0};
m_sockMap[nUserID]->Read(&ctrl_head_resp, sizeof(J_CtrlHead));
if (ctrl_head_resp.ret != 0)
{
//错误处理
}
}
return 0;
}
char *CXSdk::GetResList(int nUserID)
{
char *xml_data = NULL;
J_CtrlHead getres_head_req = {0};
MakeHeader((char *)&getres_head_req, m_usrMap[nUserID].id.usr_id, jo_list_res_req, jo_intact_pack, 0, sizeof(J_LoginData));
m_sockMap[nUserID]->Write(&getres_head_req, sizeof(J_CtrlHead));
J_CtrlHead getres_head_resp = {0};
m_sockMap[nUserID]->Read(&getres_head_resp, sizeof(getres_head_resp));
if (getres_head_resp.ret == 0)
{
if (getres_head_resp.flag == 0)
{
int nDataLen = ntohs(getres_head_resp.ex_length);
xml_data = new char[nDataLen + 1];
m_sockMap[nUserID]->Read(xml_data, nDataLen);
xml_data[nDataLen] = '\0';
return xml_data;
}
}
return NULL;
}
/*
*----------------------------------------------------------------------
*
* ProcessManagementRecord --
*
* Reads and responds to a management record. The only type of
* management record this library understands is FCGI_GET_VALUES.
* The only variables that this library's FCGI_GET_VALUES
* understands are FCGI_MAX_CONNS, FCGI_MAX_REQS, and FCGI_MPXS_CONNS.
* Ignore other FCGI_GET_VALUES variables; respond to other
* management records with a FCGI_UNKNOWN_TYPE record.
*
*----------------------------------------------------------------------
*/
static int ProcessManagementRecord(int type, FCGX_Stream * stream)
{
FCGX_Stream_Data *data = (FCGX_Stream_Data *) stream->data;
ParamsPtr paramsPtr = NewParams(3);
char **pPtr;
char response[64]; /* 64 = 8 + 3*(1+1+14+1)* + padding */
char *responseP = &response[FCGI_HEADER_LEN];
char *name, value = '\0';
int len, paddedLen;
if (type == FCGI_GET_VALUES) {
ReadParams(paramsPtr, stream);
if ((FCGX_GetError(stream) != 0) || (data->contentLen != 0)) {
FreeParams(¶msPtr);
return FCGX_PROTOCOL_ERROR;
}
for (pPtr = paramsPtr->vec; pPtr < paramsPtr->cur; pPtr++) {
name = *pPtr;
*(strchr(name, '=')) = '\0';
if (strcmp(name, FCGI_MAX_CONNS) == 0) {
value = '1';
} else if (strcmp(name, FCGI_MAX_REQS) == 0) {
value = '1';
} else if (strcmp(name, FCGI_MPXS_CONNS) == 0) {
value = '0';
} else {
name = NULL;
}
if (name != NULL) {
#include <fmt.h>
len = strlen(name);
responseP[0] = (char)len;
responseP[1] = (char)1;
fmt_str(responseP + 2, name);
responseP[2 + len] = value;
responseP[3 + len] = '\0';
// sprintf(responseP, "%c%c%s%c", len, 1, name, value);
responseP += len + 3;
}
}
len = responseP - &response[FCGI_HEADER_LEN];
paddedLen = AlignInt8(len);
*((FCGI_Header *) response)
= MakeHeader(FCGI_GET_VALUES_RESULT,
FCGI_NULL_REQUEST_ID, len, paddedLen - len);
FreeParams(¶msPtr);
} else {
paddedLen = len = sizeof(FCGI_UnknownTypeBody);
((FCGI_UnknownTypeRecord *) response)->header
= MakeHeader(FCGI_UNKNOWN_TYPE, FCGI_NULL_REQUEST_ID,
len, 0);
((FCGI_UnknownTypeRecord *) response)->body
= MakeUnknownTypeBody(type);
}
if (write_it_all(data->reqDataPtr->ipcFd, response,
FCGI_HEADER_LEN + paddedLen) < 0) {
SetError(stream, OS_Errno);
return -1;
}
return MGMT_RECORD;
}
/*
** int Compress(char ARG_PTR *pszSource, char ARG_PTR *pszDest,
** BYTE byteAlgorithm, BYTE byteExtensionChar);
**
** Compress one file to another.
**
** Arguments: pszSource - name of file to compress
** pszDest - name of compressed output file
** byteAlgorithm - compression algorithm to use
** byteExtensionChar - compressed file name extension character
**
** Returns: int - TRUE if compression finished successfully. One of the
** LZERROR_ codes if not.
**
** Globals: none
*/
INT Compress(
NOTIFYPROC pfnNotify,
CHAR ARG_PTR *pszSource,
CHAR ARG_PTR *pszDest,
BYTE byteAlgorithm,
BOOL bDoRename,
PLZINFO pLZI)
{
INT doshSource, // input file handle
doshDest, // output file handle
nRetVal = TRUE;
FH FHOut; // compressed header info struct
CHAR szDestFileName[MAX_PATH];
BYTE byteExtensionChar;
// Sanity check
if (!pLZI) {
return(LZERROR_GLOBLOCK);
}
// Set up input file handle. Set cblInSize to length of input file.
if ((nRetVal = GetIOHandle(pszSource, READ_IT, & doshSource, &pLZI->cblInSize)) != TRUE)
return(nRetVal);
// Rewind input file.
if (FSEEK(doshSource, 0L, SEEK_SET) != 0L)
{
FCLOSE(doshSource);
return(LZERROR_BADINHANDLE);
}
// Create destination file name.
STRCPY(szDestFileName, pszDest);
if (bDoRename == TRUE)
// Rename output file.
byteExtensionChar = MakeCompressedName(szDestFileName);
else
byteExtensionChar = '\0';
// Ask if we should compress this file.
if (! (*pfnNotify)(pszSource, szDestFileName, NOTIFY_START_COMPRESS))
{
// Don't compress file. This error condition should be handled in
// pfnNotify, so indicate that it is not necessary for the caller to
// display an error message.
FCLOSE(doshSource);
return(BLANK_ERROR);
}
// Set up output file handle.
if ((nRetVal = GetIOHandle(szDestFileName, WRITE_IT, & doshDest, &pLZI->cblInSize)) != TRUE)
{
FCLOSE(doshSource);
return(nRetVal);
}
// Fill in compressed file header.
MakeHeader(& FHOut, byteAlgorithm, byteExtensionChar, pLZI);
// Write compressed file header to output file.
if ((nRetVal = WriteHdr(& FHOut, doshDest, pLZI)) != TRUE)
goto COMPRESS_EXIT;
// Compress input file into output file.
switch (byteAlgorithm)
{
case ALG_FIRST:
#if 0
case ALG_LZ:
#endif
nRetVal = LZEncode(doshSource, doshDest, pLZI);
break;
default:
nRetVal = LZERROR_UNKNOWNALG;
break;
}
if (nRetVal != TRUE)
goto COMPRESS_EXIT;
// Copy date and time stamp from source file to destination file.
nRetVal = CopyDateTimeStamp(doshSource, doshDest);
COMPRESS_EXIT:
// Close files.
FCLOSE(doshSource);
FCLOSE(doshDest);
return(nRetVal);
}
int main(int argc, char **argv, char **envp)
{
int count;
FCGX_Stream *paramsStream;
fd_set readFdSet, writeFdSet;
int numFDs, selectStatus;
unsigned char headerBuff[8];
int headerLen, valueLen;
char *equalPtr;
FCGI_BeginRequestRecord beginRecord;
int doBind, doStart, nServers;
char appPath[MAXPATHLEN], bindPath[MAXPATHLEN];
if(ParseArgs(argc, argv, &doBind, &doStart,
(char *) &bindPath, (char *) &appPath, &nServers)) {
fprintf(stderr,
"Usage:\n"
" cgi-fcgi -f <cmdPath> , or\n"
" cgi-fcgi -connect <connName> <appPath> [<nServers>] , or\n"
" cgi-fcgi -start -connect <connName> <appPath> [<nServers>] , or\n"
" cgi-fcgi -bind -connect <connName> ,\n"
"where <connName> is either the pathname of a UNIX domain socket\n"
"or (if -bind is given) a hostName:portNumber specification\n"
"or (if -start is given) a :portNumber specification (uses local host).\n");
exit(1);
}
if(doBind) {
appServerSock = OS_FcgiConnect(bindPath);
}
if(doStart && (!doBind || appServerSock < 0)) {
FCGI_Start(bindPath, appPath, nServers);
if(!doBind) {
exit(0);
} else {
appServerSock = OS_FcgiConnect(bindPath);
}
}
if(appServerSock < 0) {
fprintf(stderr, "Could not connect to %s\n", bindPath);
exit(errno);
}
/*
* Set an arbitrary non-null FCGI RequestId
*/
requestId = 1;
/*
* XXX: Send FCGI_GET_VALUES
*/
/*
* XXX: Receive FCGI_GET_VALUES_RESULT
*/
/*
* Send FCGI_BEGIN_REQUEST (XXX: hack, separate write)
*/
beginRecord.header = MakeHeader(FCGI_BEGIN_REQUEST, requestId,
sizeof(beginRecord.body), 0);
beginRecord.body = MakeBeginRequestBody(FCGI_RESPONDER, TRUE);
count = write(appServerSock, &beginRecord, sizeof(beginRecord));
if(count != sizeof(beginRecord)) {
exit(errno);
}
/*
* Send environment to the FCGI application server
*/
paramsStream = CreateWriter(appServerSock, requestId, 8192, FCGI_PARAMS);
for( ; *envp != NULL; envp++) {
equalPtr = strchr(*envp, '=');
if(equalPtr == NULL) {
exit(1000);
}
valueLen = strlen(equalPtr + 1);
FCGIUtil_BuildNameValueHeader(
equalPtr - *envp,
valueLen,
&headerBuff[0],
&headerLen);
if(FCGX_PutStr((char *) &headerBuff[0], headerLen, paramsStream) < 0
|| FCGX_PutStr(*envp, equalPtr - *envp, paramsStream) < 0
|| FCGX_PutStr(equalPtr + 1, valueLen, paramsStream) < 0) {
exit(FCGX_GetError(paramsStream));
}
}
FCGX_FClose(paramsStream);
FreeStream(¶msStream);
/*
* Perform the event loop until AppServerReadHander sees FCGI_END_REQUEST
*/
fromWS.stop = fromWS.next = &fromWS.buff[0];
webServerReadHandlerEOF = FALSE;
FD_ZERO(&readFdSet);
FD_ZERO(&writeFdSet);
numFDs = max(appServerSock, STDIN_FILENO) + 1;
SetFlags(appServerSock, O_NONBLOCK);
for(;;) {
if((fromWS.stop == fromWS.next) && !webServerReadHandlerEOF) {
FD_SET(STDIN_FILENO, &readFdSet);
} else {
FD_CLR(STDIN_FILENO, &readFdSet);
}
if(fromWS.stop != fromWS.next) {
FD_SET(appServerSock, &writeFdSet);
} else {
FD_CLR(appServerSock, &writeFdSet);
}
FD_SET(appServerSock, &readFdSet);
selectStatus = select(numFDs, &readFdSet, &writeFdSet, NULL, NULL);
if(selectStatus < 0) {
exit(errno);
}
if(selectStatus == 0) {
/*
* Should not happen, no select timeout.
*/
continue;
}
if(FD_ISSET(STDIN_FILENO, &readFdSet)) {
WebServerReadHandler();
}
if(FD_ISSET(appServerSock, &writeFdSet)) {
AppServerWriteHandler();
}
if(FD_ISSET(appServerSock, &readFdSet)) {
AppServerReadHandler();
}
if(exitStatusSet) {
exit(exitStatus);
}
}
}
void enviaACK( BYTE dest ){
BYTE buffer[4];
MakeHeader( buffer, sizeof( buffer ), dest, ACK );
enviarPacotePC( buffer, sizeof( buffer ));
}
