ULXR_API_IMPL(Cpp8BitString) HttpClient::msgPOST(
                     const Cpp8BitString &msg,
                     const CppString &type,
                     const CppString &resource)
{
  ULXR_TRACE(ULXR_PCHAR("msgPOST"));
  Cpp8BitString ret;

  if (!protocol->isOpen() )
    protocol->open();

  sendAuthentication();
  protocol->sendRequestHeader(ULXR_PCHAR("POST"), resource, type, msg.length());
  protocol->writeBody(msg.data(), msg.length());

  StringProcessor sp (ret);
  receiveResponse(sp);

  if (getHttpStatus() != 200)
    throw ConnectionException(TransportError, getHttpPhrase(), getHttpStatus());

  if (!protocol->isPersistent() )
    protocol->close();

  return ret;
}
ULXR_API_IMPL(void) HttpClient::filePUT(const CppString &filename,
                                     const CppString &type,
                                     const CppString &resource)
{
  ULXR_TRACE(ULXR_PCHAR("filePUT"));

  if (!protocol->isOpen() )
    protocol->open();

  FILE *ifs = fopen (getLatin1(filename).c_str(), "rb");
  if (ifs == 0)
    throw Exception(SystemError,
                    ulxr_i18n(ULXR_PCHAR("Cannot open file: "))+filename);

  struct stat statbuf;
  if (0 != stat (getLatin1(filename).c_str(), &statbuf) )
    throw Exception(SystemError,
                    ulxr_i18n(ULXR_PCHAR("Could not get information about file: "))+filename);

  sendAuthentication();
  protocol->sendRequestHeader(ULXR_PCHAR("PUT"), resource, type, statbuf.st_size);

  char buffer [ULXR_SEND_BUFFER_SIZE];
  long readed;
  try {
    while (!feof(ifs))
    {
      readed = fread(buffer, 1, sizeof(buffer), ifs);
      if (readed < 0)
        throw Exception(SystemError,
                        ulxr_i18n(ULXR_PCHAR("Could not read from file: "))+filename);
      protocol->writeBody(buffer, readed);
    }
  }
  catch (...)
  {
    fclose(ifs);
    throw;
  }

//  bool eof_reached = feof(ifs);
  fclose(ifs);

  BodyProcessor bp;
  receiveResponse(bp);

  if (getHttpStatus() != 200)
    throw ConnectionException(TransportError,
                              getHttpPhrase(), getHttpStatus());

  if (!protocol->isPersistent() )
    protocol->close();
}
Beispiel #3
0
// 404
void respErrorPage( headerOut *header_out , int status_code )
{
	if (status_code >= 400 && status_code <= 507)
	{
		int ret = respDefinedErrorPage( header_out , status_code );
		if (ret == AE_TRUE)
		{
			return;
		}
	}
	
	// get header info
	headerStatus error_page = getHttpStatus( status_code );
	int datalen = strlen( error_page.data );
	
	// header append
	createCommonHeader( header_out , status_code );
	headerAppendLength( header_out , datalen );
	appendRespHeader( header_out , HEADER_END_LINE );
	
	// send
	httpResponseWrite( header_out->req->connfd , header_out->data ,
			header_out->length );
	if (header_out->req->nobody != AE_TRUE)
	{
		httpResponseWrite( header_out->req->connfd , error_page.data , datalen );
	}
	// nobody强制关闭
	httpClose( header_out->req , header_out->req->nobody );
}
Beispiel #4
0
// this function only process status=200 page, not include resp_error_page
void createCommonHeader( headerOut *header_out , int status_code )
{
	headerStatus error_page = getHttpStatus( status_code );
	// header append
	appendRespHeader( header_out , HEADER_STATUS , error_page.status );
	appendRespHeader( header_out , HEADER_SERVER );
	appendRespHeader( header_out , HEADER_CONTENT_TYPE );
	appendRespHeader( header_out , HEADER_KEEP_ALIVE );
}
ULXR_API_IMPL(void) HttpClient::doDELETE(const CppString &resource)
{
  ULXR_TRACE(ULXR_PCHAR("doDELETE"));

  if (!protocol->isOpen() )
    protocol->open();

  sendAuthentication();
  protocol->sendRequestHeader(ULXR_PCHAR("DELETE"), resource, ULXR_PCHAR(""), 0);

  BodyProcessor bp;
  receiveResponse(bp);

  if (getHttpStatus() != 200)
    throw ConnectionException(TransportError, getHttpPhrase(), getHttpStatus());

  if (!protocol->isPersistent() )
    protocol->close();
}
ULXR_API_IMPL(void) HttpClient::fileGET(const CppString &filename,
                                     const CppString &resource)
{
  ULXR_TRACE(ULXR_PCHAR("fileGET"));

  if (!protocol->isOpen() )
    protocol->open();

  std::ofstream ofs (getLatin1(filename).c_str(), std::ios::out | std::ios::binary);
  if (!ofs.good() )
    throw Exception(SystemError, ulxr_i18n(ULXR_PCHAR("Cannot create file: "))+filename);

  sendAuthentication();
  protocol->sendRequestHeader(ULXR_PCHAR("GET"), resource, ULXR_PCHAR(""), 0);

  FileProcessor fp(ofs, filename);
  receiveResponse(fp);

  if (getHttpStatus() != 200)
    throw ConnectionException(TransportError, getHttpPhrase(), getHttpStatus());

  if (!protocol->isPersistent() )
    protocol->close();
}
ULXR_API_IMPL(void) HttpClient::msgPUT(const Cpp8BitString &msg, const CppString &type,
                                    const CppString &resource)
{
  ULXR_TRACE(ULXR_PCHAR("msgPUT"));

  if (!protocol->isOpen() )
    protocol->open();

  sendAuthentication();
  protocol->sendRequestHeader(ULXR_PCHAR("PUT"), resource, type, msg.length());
#ifdef ULXR_USE_WXSTRING
  protocol->writeBody(msg.data(), msg.length());
#else
  protocol->writeBody(msg.data(), msg.length());
#endif

  BodyProcessor bp;
  receiveResponse(bp);
  if (getHttpStatus() != 200)
    throw ConnectionException(TransportError, getHttpPhrase(), getHttpStatus());

  if (!protocol->isPersistent() )
    protocol->close();
}
Beispiel #8
0
void httpRedirect( httpHeader *req_header , char *uri )
{
	headerOut header_out;
	memset( &header_out , 0 , sizeof( header_out ) );
	header_out.req = req_header;
	headerStatus error_page = getHttpStatus( 301 ); // header append
			
	createCommonHeader( &header_out , 301 );
	appendRespHeader( &header_out , HEADER_LOCATION , uri );
	appendRespHeader( &header_out , HEADER_CONTENT_LENGTH , 0 );
	appendRespHeader( &header_out , HEADER_END_LINE );
	
	httpResponseWrite( req_header->connfd , header_out.data , header_out.length );
	httpClose( req_header , 0 );
}
void checkAndGzip(buffer *tmpFilePath, buffer *targetFilePath, buffer *expectFilePath, buffer *responsePath){
	char *responseCnt = readResponse(responsePath->ptr);
	int httpStatus = getHttpStatus(responseCnt);
	if(200 == httpStatus) {
		if(-1 != rename(tmpFilePath->ptr, targetFilePath->ptr)) {
			//system invoke unzip
			buffer *unzipCmd = buffer_init_size(20 + targetFilePath->used + expectFilePath->used);
			stringAppend(unzipCmd, GZIP_CMD, GZIP_CMD_LEN);
			stringAppend(unzipCmd, targetFilePath->ptr, targetFilePath->used);
			stringAppend(unzipCmd, " > ", 3);
			stringAppend(unzipCmd, expectFilePath->ptr, expectFilePath->used);

			debug_buffer(unzipCmd, "unzipCmd");
			if(-1 == system(unzipCmd->ptr)) {
				fprintf(stderr, "system(gzip....) error:%s\n", unzipCmd->ptr);
				exit(5);
			}
			buffer_free(unzipCmd);
		}
	}
	free(responseCnt);
}
void intervalWork(VersionUpdateConfig *config) {

	if(debug) {
		fprintf(stdout, "start intervalWork\n");
	}
	//clean old responsefile
	remove(config->reponseFilePath->ptr);

	buffer *lastModifiedTime = NULL;

	int paramLen = config->URLDomain->used + config->tmpVersionFilePath->used + config->reponseFilePath->used;
	buffer *param = buffer_init_size(20 + paramLen);
	stringAppend(param, " ", 1);
	stringAppend(param, config->URLDomain->ptr, config->URLDomain->used);
	stringAppend(param, " -O ", 4);
	stringAppend(param, config->tmpVersionFilePath->ptr, config->tmpVersionFilePath->used);
	stringAppend(param, " > ", 3);
	stringAppend(param, config->reponseFilePath->ptr, config->reponseFilePath->used);
	stringAppend(param, " 2>&1 ", 6);

	while(1) {
		char *responseCnt = readResponse(config->reponseFilePath->ptr);
		int httpStatus = getHttpStatus(responseCnt);
		if(debug) {
			fprintf(stdout, "httpStatus:%d\n", httpStatus);
		}
		// ignore the lock checke for the first version file request
		if(0 != httpStatus && 404 != httpStatus) {
			int bLocked = checkLockStatus(config->lockRequestURL->ptr);
			if(bLocked){
				sleep(config->intervalSecond);
				continue;
			}
		}
		if(304 != httpStatus) {
			getLastModified(responseCnt, &lastModifiedTime);
		}
		debug_buffer(lastModifiedTime, "lastModifiedTime");
		
		//thread interval exec
		buffer *cmdBuf = buffer_init_size(LAST_MODIFIED_LEN + WGET_CMD_LEN + HEADER_LEN + param->used);
		stringAppend(cmdBuf, WGET_CMD, WGET_CMD_LEN);
		if(NULL != lastModifiedTime) {
			stringAppend(cmdBuf, HEADER, HEADER_LEN);
			stringAppend(cmdBuf, lastModifiedTime->ptr, lastModifiedTime->used);
			stringAppend(cmdBuf, "\"", 1);
		}
		stringAppend(cmdBuf, param->ptr, param->used);
		debug_buffer(cmdBuf, "cmdBuf");

		if(-1 == system(cmdBuf->ptr)) {
			fprintf(stderr, "system (wget...) error:%s\n", cmdBuf->ptr);
			exit(4);
		}

		free(responseCnt);
		buffer_free(cmdBuf);

		checkAndGzip(config->tmpVersionFilePath, config->versionFilePath,
					config->expectVersionFilePath, config->reponseFilePath);

		sleep(config->intervalSecond);
	}
}