virtual ~orderbot() { curl_easy_cleanup(m_curl); curl_global_cleanup(); }
int main(void) { int i; CURL *curl; CURLcode res; FILE *headerfile; const char *pPassphrase = NULL; static const char *pCertFile = "testcert.pem"; static const char *pCACertFile = "cacert.pem"; const char *pKeyName; const char *pKeyType; const char *pEngine; #ifdef USE_ENGINE pKeyName = "rsa_test"; pKeyType = "ENG"; pEngine = "chil"; /* for nChiper HSM... */ #else pKeyName = "testkey.pem"; pKeyType = "PEM"; pEngine = NULL; #endif headerfile = fopen("dumpit", "w"); curl_global_init(CURL_GLOBAL_DEFAULT); curl = curl_easy_init(); if (curl) { /* what call to write: */ curl_easy_setopt(curl, CURLOPT_URL, "HTTPS://your.favourite.ssl.site"); curl_easy_setopt(curl, CURLOPT_HEADERDATA, headerfile); for (i = 0; i < 1; i++) { /* single-iteration loop, just to break out from */ if (pEngine) { /* use crypto engine */ if (curl_easy_setopt(curl, CURLOPT_SSLENGINE, pEngine) != CURLE_OK) { /* load the crypto engine */ fprintf(stderr, "can't set crypto engine\n"); break; } if (curl_easy_setopt(curl, CURLOPT_SSLENGINE_DEFAULT, 1L) != CURLE_OK) { /* set the crypto engine as default */ /* only needed for the first time you load a engine in a curl object... */ fprintf(stderr, "can't set crypto engine as default\n"); break; } } /* cert is stored PEM coded in file... */ /* since PEM is default, we needn't set it for PEM */ curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, "PEM"); /* set the cert for client authentication */ curl_easy_setopt(curl, CURLOPT_SSLCERT, pCertFile); /* sorry, for engine we must set the passphrase (if the key has one...) */ if (pPassphrase) curl_easy_setopt(curl, CURLOPT_KEYPASSWD, pPassphrase); /* if we use a key stored in a crypto engine, we must set the key type to "ENG" */ curl_easy_setopt(curl, CURLOPT_SSLKEYTYPE, pKeyType); /* set the private key (file or ID in engine) */ curl_easy_setopt(curl, CURLOPT_SSLKEY, pKeyName); /* set the file with the certs vaildating the server */ curl_easy_setopt(curl, CURLOPT_CAINFO, pCACertFile); /* disconnect if we can't validate server's cert */ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L); /* Perform the request, res will get the return code */ res = curl_easy_perform(curl); /* Check for errors */ if (res != CURLE_OK) fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res)); /* we are done... */ } /* always cleanup */ curl_easy_cleanup(curl); } curl_global_cleanup(); return 0; }
int gurls( FILE* fin, uint32_t threads ) { struct thread_pool *pool; uint32_t i; char url[1024]; char saftey_ext[5] = "txt\0"; /* validate threads */ threads = threads > 30 ? 30 : threads == 0 ? 5 : threads; pool = thread_pool_new( threads ); if( !pool ) { return -1; } /* initialize curl */ curl_global_init( CURL_GLOBAL_ALL ); for( i = 0; fgets(url, 1024, fin) ; i++ ) { gurl_url_t* u; char* aux; if( *url == '\n' || *url == '\0' ) { break; } if( !is_url(url) ) { i--; continue; } /* create url object */ u = malloc( sizeof(gurl_url_t) ); if( !u ) { break; } /* remove trailing newline */ for( aux = url; aux-url < 1024 && *aux != '\n' && *aux != '\0'; aux++ ); *aux = '\0'; /* fill up url object */ strncpy( u->url, url, 1024 ); aux = get_extension( url ); if( !aux ) aux = saftey_ext; snprintf( u->filename, 1024, "file-%010d.%s", i, aux ); thread_pool_push( pool, gurl_url_download, u ); } /* send term signal to children */ thread_pool_terminate( pool ); /* cleanup */ thread_pool_free( pool ); curl_global_cleanup(); return 0; }
int main(int argc, char **argv) { CURL *curl; CURLcode res; FILE *hd_src; struct stat file_info; curl_off_t fsize; struct curl_slist *headerlist=NULL; static const char buf_1 [] = "RNFR " UPLOAD_FILE_AS; static const char buf_2 [] = "RNTO " RENAME_FILE_TO; /* get the file size of the local file */ if(stat(LOCAL_FILE, &file_info)) { printf("Couldnt open '%s': %s\n", LOCAL_FILE, strerror(errno)); return 1; } fsize = (curl_off_t)file_info.st_size; printf("Local file size: %" CURL_FORMAT_CURL_OFF_T " bytes.\n", fsize); /* get a FILE * of the same file */ hd_src = fopen(LOCAL_FILE, "rb"); /* In windows, this will init the winsock stuff */ curl_global_init(CURL_GLOBAL_ALL); /* get a curl handle */ curl = curl_easy_init(); if(curl) { /* build a list of commands to pass to libcurl */ headerlist = curl_slist_append(headerlist, buf_1); headerlist = curl_slist_append(headerlist, buf_2); /* we want to use our own read function */ curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback); /* enable uploading */ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L); /* specify target */ curl_easy_setopt(curl,CURLOPT_URL, REMOTE_URL); /* pass in that last of FTP commands to run after the transfer */ curl_easy_setopt(curl, CURLOPT_POSTQUOTE, headerlist); /* now specify which file to upload */ curl_easy_setopt(curl, CURLOPT_READDATA, hd_src); /* Set the size of the file to upload (optional). If you give a *_LARGE option you MUST make sure that the type of the passed-in argument is a curl_off_t. If you use CURLOPT_INFILESIZE (without _LARGE) you must make sure that to pass in a type 'long' argument. */ curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fsize); /* Now run off and do what you've been told! */ res = curl_easy_perform(curl); /* clean up the FTP commands list */ curl_slist_free_all (headerlist); /* always cleanup */ curl_easy_cleanup(curl); } fclose(hd_src); /* close the local file */ curl_global_cleanup(); return 0; }
int Send_Mail_From_Ssl(const char* pUser, const char* pPass, const char* pFrom, const char* pTo, const char* pUrl, const char* pTitle, const char* pData) { #ifdef __THREE_LIBRARY_CURL__ CURL* curl; CURLM* mcurl; int still_running = 1; struct timeval mp_start; struct WriteThis pooh; struct curl_slist* rcpt_list = NULL; //组装发送内容 char** textList = new char* [5]; for (int i = 0; i < 5; i++) { textList[i] = new char[1024]; memset(textList[i], 0, 1024); } sprintf(textList[0], "Subject: %s\n", pTitle); sprintf(textList[1], "\n"); sprintf(textList[2], "%s\n", pData); sprintf(textList[3], "\n"); textList[4] = NULL; pooh.counter = 0; pooh.pText = textList; curl_global_init(CURL_GLOBAL_DEFAULT); curl = curl_easy_init(); if (!curl) { return 1; } mcurl = curl_multi_init(); if (!mcurl) { return 2; } rcpt_list = curl_slist_append(rcpt_list, pTo); /* more addresses can be added here rcpt_list = curl_slist_append(rcpt_list, "<*****@*****.**>"); */ curl_easy_setopt(curl, CURLOPT_URL, pUrl); // 此处的要带上smtp端口 curl_easy_setopt(curl, CURLOPT_USERNAME, pUser); curl_easy_setopt(curl, CURLOPT_PASSWORD, pPass); curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback); curl_easy_setopt(curl, CURLOPT_MAIL_FROM, pFrom); curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, rcpt_list); curl_easy_setopt(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_ALL); curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); curl_easy_setopt(curl, CURLOPT_READDATA, &pooh); curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); curl_easy_setopt(curl, CURLOPT_SSLVERSION, 0L); curl_easy_setopt(curl, CURLOPT_SSL_SESSIONID_CACHE, 0L); curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L); curl_multi_add_handle(mcurl, curl); mp_start = tvnow(); /* we start some action by calling perform right away */ curl_multi_perform(mcurl, &still_running); while (still_running) { struct timeval timeout; int rc; /* select() return code */ fd_set fdread; fd_set fdwrite; fd_set fdexcep; int maxfd = -1; long curl_timeo = -1; FD_ZERO(&fdread); FD_ZERO(&fdwrite); FD_ZERO(&fdexcep); /* set a suitable timeout to play around with */ timeout.tv_sec = 1; timeout.tv_usec = 0; curl_multi_timeout(mcurl, &curl_timeo); if (curl_timeo >= 0) { timeout.tv_sec = curl_timeo / 1000; if (timeout.tv_sec > 1) { timeout.tv_sec = 1; } else { timeout.tv_usec = (curl_timeo % 1000) * 1000; } } /* get file descriptors from the transfers */ curl_multi_fdset(mcurl, &fdread, &fdwrite, &fdexcep, &maxfd); /* In a real-world program you OF COURSE check the return code of the function calls. On success, the value of maxfd is guaranteed to be greater or equal than -1. We call select(maxfd + 1, ...), specially in case of (maxfd == -1), we call select(0, ...), which is basically equal to sleep. */ rc = select(maxfd + 1, &fdread, &fdwrite, &fdexcep, &timeout); if (tvdiff(tvnow(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) { fprintf(stderr, "ABORTING TEST, since it seems " "that it would have run forever.\n"); break; } switch (rc) { case -1: /* select error */ break; case 0: /* timeout */ default: /* action */ curl_multi_perform(mcurl, &still_running); break; } } for (int i = 0; i < 5; i++) { delete[] textList[i]; } delete[] textList; curl_slist_free_all(rcpt_list); curl_multi_remove_handle(mcurl, curl); curl_multi_cleanup(mcurl); curl_easy_cleanup(curl); curl_global_cleanup(); return 0; #else return 0; #endif }
int test(char *URL) { int res = 0; CURL *curl; FILE *hd_src ; int hd ; int error; struct_stat file_info; CURLM *m = NULL; struct timeval ml_start; char ml_timedout = FALSE; struct ReadWriteSockets sockets = {{0, 0}, {0, 0}}; struct timeval timeout = {-1, 0}; int success = 0; if (!libtest_arg3) { fprintf(stderr, "Usage: lib582 [url] [filename] [username]\n"); return -1; } hd_src = fopen(libtest_arg2, "rb"); if(NULL == hd_src) { error = ERRNO; fprintf(stderr, "fopen() failed with error: %d %s\n", error, strerror(error)); fprintf(stderr, "Error opening file: %s\n", libtest_arg2); return TEST_ERR_MAJOR_BAD; } /* get the file size of the local file */ hd = fstat(fileno(hd_src), &file_info); if(hd == -1) { /* can't open file, bail out */ error = ERRNO; fprintf(stderr, "fstat() failed with error: %d %s\n", error, strerror(error)); fprintf(stderr, "ERROR: cannot open file %s\n", libtest_arg2); fclose(hd_src); return -1; } fprintf(stderr, "Set to upload %d bytes\n", (int)file_info.st_size); if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) { fprintf(stderr, "curl_global_init() failed\n"); fclose(hd_src); return TEST_ERR_MAJOR_BAD; } if ((curl = curl_easy_init()) == NULL) { fprintf(stderr, "curl_easy_init() failed\n"); fclose(hd_src); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } /* enable uploading */ test_setopt(curl, CURLOPT_UPLOAD, 1L); /* specify target */ test_setopt(curl,CURLOPT_URL, URL); /* go verbose */ test_setopt(curl, CURLOPT_VERBOSE, 1L); /* now specify which file to upload */ test_setopt(curl, CURLOPT_READDATA, hd_src); test_setopt(curl, CURLOPT_USERPWD, libtest_arg3); test_setopt(curl, CURLOPT_SSH_PUBLIC_KEYFILE, "curl_client_key.pub"); test_setopt(curl, CURLOPT_SSH_PRIVATE_KEYFILE, "curl_client_key"); test_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_info.st_size); if ((m = curl_multi_init()) == NULL) { fprintf(stderr, "curl_multi_init() failed\n"); curl_easy_cleanup(curl); curl_global_cleanup(); fclose(hd_src); return TEST_ERR_MAJOR_BAD; } test_multi_setopt(m, CURLMOPT_SOCKETFUNCTION, curlSocketCallback); test_multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets); test_multi_setopt(m, CURLMOPT_TIMERFUNCTION, curlTimerCallback); test_multi_setopt(m, CURLMOPT_TIMERDATA, &timeout); if ((res = (int)curl_multi_add_handle(m, curl)) != CURLM_OK) { fprintf(stderr, "curl_multi_add_handle() failed, " "with code %d\n", res); curl_multi_cleanup(m); curl_easy_cleanup(curl); curl_global_cleanup(); fclose(hd_src); return TEST_ERR_MAJOR_BAD; } ml_timedout = FALSE; ml_start = tutil_tvnow(); while (!checkForCompletion(m, &success)) { fd_set readSet, writeSet; curl_socket_t maxFd = 0; struct timeval tv = {10, 0}; if (tutil_tvdiff(tutil_tvnow(), ml_start) > MAIN_LOOP_HANG_TIMEOUT) { ml_timedout = TRUE; break; } FD_ZERO(&readSet); FD_ZERO(&writeSet); updateFdSet(&sockets.read, &readSet, &maxFd); updateFdSet(&sockets.write, &writeSet, &maxFd); if (timeout.tv_sec != -1) { int usTimeout = getMicroSecondTimeout(&timeout); tv.tv_sec = usTimeout / 1000000; tv.tv_usec = usTimeout % 1000000; } else if (maxFd <= 0) { tv.tv_sec = 0; tv.tv_usec = 100000; } select_test(maxFd, &readSet, &writeSet, NULL, &tv); /* Check the sockets for reading / writing */ checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN, "read"); checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT, "write"); if (timeout.tv_sec != -1 && getMicroSecondTimeout(&timeout) == 0) { /* Curl's timer has elapsed. */ notifyCurl(m, CURL_SOCKET_TIMEOUT, 0, "timeout"); } } if (!success) { fprintf(stderr, "Error uploading file.\n"); res = TEST_ERR_MAJOR_BAD; } else if (ml_timedout) { fprintf(stderr, "ABORTING TEST, since it seems " "that it would have run forever.\n"); res = TEST_ERR_RUNS_FOREVER; } test_cleanup: if(m) curl_multi_remove_handle(m, curl); curl_easy_cleanup(curl); if(m) { fprintf(stderr, "Now multi-cleanup!\n"); curl_multi_cleanup(m); } fclose(hd_src); /* close the local file */ if (sockets.read.sockets != 0) free(sockets.read.sockets); if (sockets.write.sockets != 0) free(sockets.write.sockets); curl_global_cleanup(); return res; }
int main(int argc, char **argv) { bstring info_page; info_t info; yajl_gen yajl; const unsigned char *json; size_t json_len; curl_global_init(CURL_GLOBAL_NOTHING); for (size_t i = 0; argv[i]; i += 1) { if (strcmp(argv[i], "-r") == 0) { modem_touch(MODEM_RESTART_URL); return EXIT_SUCCESS; } } info_page = modem_fetch(MODEM_INFO_URL); if (!info_page) { fprintf(stderr, "hektor: Couldn't fetch '%s'\n", MODEM_INFO_URL); return EXIT_FAILURE; } info_init(&info, info_page); yajl = yajl_gen_alloc(NULL); assert(yajl); yajl_gen_config(yajl, yajl_gen_beautify, true); #define yajl_gen_strst(y, s) yajl_gen_string((y), (s), sizeof(s) - 1) yajl_gen_map_open(yajl); yajl_gen_strst(yajl, "connection"); yajl_gen_integer(yajl, info.conn); yajl_gen_strst(yajl, "fapped"); yajl_gen_bool(yajl, info.fap == FAP_ACTIVE); yajl_gen_strst(yajl, "refill_secs"); yajl_gen_integer(yajl, info.refill_secs); yajl_gen_strst(yajl, "refill_ts"); yajl_gen_integer(yajl, info.refill_ts); yajl_gen_strst(yajl, "usage_allowed"); yajl_gen_integer(yajl, info.usage_allowed); yajl_gen_strst(yajl, "usage_remain"); yajl_gen_integer(yajl, info.usage_remain); yajl_gen_map_close(yajl); #undef yajl_gen_strst yajl_gen_get_buf(yajl, &json, &json_len); printf("%s", json); bdestroy(info_page); yajl_gen_free(yajl); curl_global_cleanup(); return EXIT_SUCCESS; }
static void destroy(void) { curl_global_cleanup(); if(xcap_db != NULL) xcap_dbf.close(xcap_db); }
int main(int argc, char** argv) { std::cout << "Blackbird Bitcoin Arbitrage" << std::endl; std::cout << "DISCLAIMER: USE THE SOFTWARE AT YOUR OWN RISK\n" << std::endl; std::locale mylocale(""); Parameters params("blackbird.conf"); if (!params.demoMode) { if (!params.useFullCash) { if (params.cashForTesting < 10.0) { std::cout << "WARNING: Minimum test cash recommended: $10.00\n" << std::endl; } if (params.cashForTesting > params.maxExposure) { std::cout << "ERROR: Test cash ($" << params.cashForTesting << ") is above max exposure ($" << params.maxExposure << ")\n" << std::endl; return -1; } } } if (params.useDatabase) { if (createDbConnection(params) != 0) { std::cout << "ERROR: cannot connect to the database \'" << params.dbName << "\'\n" << std::endl; return -1; } } getQuoteType getQuote[10]; getAvailType getAvail[10]; sendOrderType sendOrder[10]; isOrderCompleteType isOrderComplete[10]; getActivePosType getActivePos[10]; getLimitPriceType getLimitPrice[10]; std::string dbTableName[10]; int index = 0; if (params.bitfinexApi.empty() == false || params.demoMode == true) { params.addExchange("Bitfinex", params.bitfinexFees, params.bitfinexCanShort, true); getQuote[index] = Bitfinex::getQuote; getAvail[index] = Bitfinex::getAvail; sendOrder[index] = Bitfinex::sendOrder; isOrderComplete[index] = Bitfinex::isOrderComplete; getActivePos[index] = Bitfinex::getActivePos; getLimitPrice[index] = Bitfinex::getLimitPrice; if (params.useDatabase) { dbTableName[index] = "bitfinex"; createTable(dbTableName[index], params); } index++; } if (params.okcoinApi.empty() == false || params.demoMode == true) { params.addExchange("OKCoin", params.okcoinFees, params.okcoinCanShort, true); getQuote[index] = OkCoin::getQuote; getAvail[index] = OkCoin::getAvail; sendOrder[index] = OkCoin::sendOrder; isOrderComplete[index] = OkCoin::isOrderComplete; getActivePos[index] = OkCoin::getActivePos; getLimitPrice[index] = OkCoin::getLimitPrice; if (params.useDatabase) { dbTableName[index] = "okcoin"; createTable(dbTableName[index], params); } index++; } if (params.bitstampClientId.empty() == false || params.demoMode == true) { params.addExchange("Bitstamp", params.bitstampFees, params.bitstampCanShort, true); getQuote[index] = Bitstamp::getQuote; getAvail[index] = Bitstamp::getAvail; sendOrder[index] = Bitstamp::sendOrder; isOrderComplete[index] = Bitstamp::isOrderComplete; getActivePos[index] = Bitstamp::getActivePos; getLimitPrice[index] = Bitstamp::getLimitPrice; if (params.useDatabase) { dbTableName[index] = "bitstamp"; createTable(dbTableName[index], params); } index++; } if (params.geminiApi.empty() == false || params.demoMode == true) { params.addExchange("Gemini", params.geminiFees, params.geminiCanShort, true); getQuote[index] = Gemini::getQuote; getAvail[index] = Gemini::getAvail; sendOrder[index] = Gemini::sendOrder; isOrderComplete[index] = Gemini::isOrderComplete; getActivePos[index] = Gemini::getActivePos; getLimitPrice[index] = Gemini::getLimitPrice; if (params.useDatabase) { dbTableName[index] = "gemini"; createTable(dbTableName[index], params); } index++; } if (params.krakenApi.empty() == false || params.demoMode == true) { params.addExchange("Kraken", params.krakenFees, params.krakenCanShort, true); getQuote[index] = Kraken::getQuote; getAvail[index] = Kraken::getAvail; sendOrder[index] = Kraken::sendOrder; isOrderComplete[index] = Kraken::isOrderComplete; getActivePos[index] = Kraken::getActivePos; getLimitPrice[index] = Kraken::getLimitPrice; if (params.useDatabase) { dbTableName[index] = "kraken"; createTable(dbTableName[index], params); } index++; } if (params.itbitApi.empty() == false || params.demoMode == true) { params.addExchange("ItBit", params.itbitFees, params.itbitCanShort, false); getQuote[index] = ItBit::getQuote; getAvail[index] = ItBit::getAvail; // sendOrder[index] = ItBit::sendOrder; // isOrderComplete[index] = ItBit::isOrderComplete; getActivePos[index] = ItBit::getActivePos; getLimitPrice[index] = ItBit::getLimitPrice; if (params.useDatabase) { dbTableName[index] = "itbit"; createTable(dbTableName[index], params); } index++; } if (params.btceApi.empty() == false || params.demoMode == true) { params.addExchange("BTC-e", params.btceFees, params.btceCanShort, false); getQuote[index] = BTCe::getQuote; getAvail[index] = BTCe::getAvail; // sendOrder[index] = BTCe::sendOrder; // isOrderComplete[index] = BTCe::isOrderComplete; getActivePos[index] = BTCe::getActivePos; getLimitPrice[index] = BTCe::getLimitPrice; if (params.useDatabase) { dbTableName[index] = "btce"; createTable(dbTableName[index], params); } index++; } if (params.sevennintysixApi.empty() == false || params.demoMode == true) { params.addExchange("796.com", params.sevennintysixFees, params.sevennintysixCanShort, true); getQuote[index] = SevenNintySix::getQuote; getAvail[index] = SevenNintySix::getAvail; sendOrder[index] = SevenNintySix::sendOrder; isOrderComplete[index] = SevenNintySix::isOrderComplete; getActivePos[index] = SevenNintySix::getActivePos; getLimitPrice[index] = SevenNintySix::getLimitPrice; if (params.useDatabase) { dbTableName[index] = "796_com"; createTable(dbTableName[index], params); } index++; } if (index < 2) { std::cout << "ERROR: Blackbird needs at least two Bitcoin exchanges. Please edit the config.json file to add new exchanges\n" << std::endl; return -1; } std::string currDateTime = printDateTimeFileName(); std::string csvFileName = "blackbird_result_" + currDateTime + ".csv"; std::ofstream csvFile; csvFile.open(csvFileName.c_str(), std::ofstream::trunc); csvFile << "TRADE_ID,EXCHANGE_LONG,EXHANGE_SHORT,ENTRY_TIME,EXIT_TIME,DURATION,TOTAL_EXPOSURE,BALANCE_BEFORE,BALANCE_AFTER,RETURN\n"; csvFile.flush(); std::string logFileName = "blackbird_log_" + currDateTime + ".log"; std::ofstream logFile; logFile.open(logFileName.c_str(), std::ofstream::trunc); logFile.imbue(mylocale); logFile.precision(2); logFile << std::fixed; params.logFile = &logFile; logFile << "--------------------------------------------" << std::endl; logFile << "| Blackbird Bitcoin Arbitrage Log File |" << std::endl; logFile << "--------------------------------------------\n" << std::endl; logFile << "Blackbird started on " << printDateTime() << "\n" << std::endl; if (params.useDatabase) { logFile << "Connected to database \'" << params.dbName << "\'\n" << std::endl; } if (params.demoMode) { logFile << "Demo mode: trades won't be generated\n" << std::endl; } std::cout << "Log file generated: " << logFileName << "\nBlackbird is running... (pid " << getpid() << ")\n" << std::endl; std::vector<Bitcoin*> btcVec; int num_exchange = params.nbExch(); for (int i = 0; i < num_exchange; ++i) { btcVec.push_back(new Bitcoin(i, params.exchName[i], params.fees[i], params.canShort[i], params.isImplemented[i])); } curl_global_init(CURL_GLOBAL_ALL); params.curl = curl_easy_init(); logFile << "[ Targets ]" << std::endl; logFile << " Spread Entry: " << params.spreadEntry * 100.0 << "%" << std::endl; logFile << " Spread Target: " << params.spreadTarget * 100.0 << "%" << std::endl; if (params.spreadEntry <= 0.0) { logFile << " WARNING: Spread Entry should be positive" << std::endl; } if (params.spreadTarget <= 0.0) { logFile << " WARNING: Spread Target should be positive" << std::endl; } logFile << std::endl; // store current balances logFile << "[ Current balances ]" << std::endl; double* balanceUsd = (double*)malloc(sizeof(double) * num_exchange); double* balanceBtc = (double*)malloc(sizeof(double) * num_exchange); for (int i = 0; i < num_exchange; ++i) { if (params.demoMode) { balanceUsd[i] = 0.0; balanceBtc[i] = 0.0; } else { balanceUsd[i] = getAvail[i](params, "usd"); balanceBtc[i] = getAvail[i](params, "btc"); } } // contains balances after a completed trade double* newBalUsd = (double*)malloc(sizeof(double) * num_exchange); double* newBalBtc = (double*)malloc(sizeof(double) * num_exchange); memset(newBalUsd, 0.0, sizeof(double) * num_exchange); memset(newBalBtc, 0.0, sizeof(double) * num_exchange); for (int i = 0; i < num_exchange; ++i) { logFile << " " << params.exchName[i] << ":\t"; if (params.demoMode) { logFile << "n/a (demo mode)" << std::endl; } else if (!params.isImplemented[i]) { logFile << "n/a (API not implemented)" << std::endl; } else { logFile << balanceUsd[i] << " USD\t" << std::setprecision(6) << balanceBtc[i] << std::setprecision(2) << " BTC" << std::endl; } if (balanceBtc[i] > 0.0300) { logFile << "ERROR: All BTC accounts must be empty before starting Blackbird" << std::endl; return -1; } } logFile << std::endl; logFile << "[ Cash exposure ]" << std::endl; if (params.demoMode) { logFile << " No cash - Demo mode" << std::endl; } else { if (params.useFullCash) { logFile << " FULL cash used!" << std::endl; } else { logFile << " TEST cash used\n Value: $" << params.cashForTesting << std::endl; } } logFile << std::endl; time_t rawtime; rawtime = time(NULL); struct tm* timeinfo; timeinfo = localtime(&rawtime); // wait the next gapSec seconds before starting time(&rawtime); timeinfo = localtime(&rawtime); while ((int)timeinfo->tm_sec % params.gapSec != 0) { sleep(0.01); time(&rawtime); timeinfo = localtime(&rawtime); } // main loop if (!params.verbose) { logFile << "Running..." << std::endl; } bool inMarket = false; int resultId = 0; Result res; res.clear(); unsigned currIteration = 0; bool stillRunning = true; time_t currTime; time_t diffTime; while (stillRunning) { currTime = mktime(timeinfo); time(&rawtime); diffTime = difftime(rawtime, currTime); // check if we are already too late if (diffTime > 0) { logFile << "WARNING: " << diffTime << " second(s) too late at " << printDateTime(currTime) << std::endl; timeinfo->tm_sec = timeinfo->tm_sec + (ceil(diffTime / params.gapSec) + 1) * params.gapSec; currTime = mktime(timeinfo); sleep(params.gapSec - (diffTime % params.gapSec)); logFile << std::endl; } else if (diffTime < 0) { sleep(-difftime(rawtime, currTime)); // sleep until the next iteration } if (params.verbose) { if (!inMarket) { logFile << "[ " << printDateTime(currTime) << " ]" << std::endl; } else { logFile << "[ " << printDateTime(currTime) << " IN MARKET: Long " << res.exchNameLong << " / Short " << res.exchNameShort << " ]" << std::endl; } } for (int e = 0; e < num_exchange; ++e) { double bid = getQuote[e](params, true); double ask = getQuote[e](params, false); if (params.useDatabase) { addBidAskToDb(dbTableName[e], printDateTimeDb(currTime), bid, ask, params); } if (bid == 0.0) { logFile << " WARNING: " << params.exchName[e] << " bid is null, use previous one" << std::endl; } if (ask == 0.0) { logFile << " WARNING: " << params.exchName[e] << " ask is null, use previous one" << std::endl; } if (params.verbose) { logFile << " " << params.exchName[e] << ": \t" << bid << " / " << ask << std::endl; } btcVec[e]->updateData(bid, ask, 0.0); curl_easy_reset(params.curl); } if (params.verbose) { logFile << " ----------------------------" << std::endl; } // compute entry point if (!inMarket) { for (int i = 0; i < num_exchange; ++i) { for (int j = 0; j < num_exchange; ++j) { if (i != j) { if (checkEntry(btcVec[i], btcVec[j], res, params)) { // entry opportunity found res.exposure = std::min(balanceUsd[res.idExchLong], balanceUsd[res.idExchShort]); if (params.demoMode) { logFile << "INFO: Opportunity found but no trade will be generated (Demo mode)" << std::endl; break; } if (res.exposure == 0.0) { logFile << "WARNING: Opportunity found but no cash available. Trade canceled" << std::endl; break; } if (params.useFullCash == false && res.exposure <= params.cashForTesting) { logFile << "WARNING: Opportunity found but no enough cash. Need more than TEST cash (min. $" << params.cashForTesting << "). Trade canceled" << std::endl; break; } if (params.useFullCash) { res.exposure -= params.untouchedCash * res.exposure; // leave untouchedCash if (res.exposure > params.maxExposure) { logFile << "WARNING: Opportunity found but exposure ($" << res.exposure << ") above the limit" << std::endl; logFile << " Max exposure will be used instead ($" << params.maxExposure << ")" << std::endl; res.exposure = params.maxExposure; } } else { res.exposure = params.cashForTesting; // use test money } double volumeLong = res.exposure / btcVec[res.idExchLong]->getAsk(); double volumeShort = res.exposure / btcVec[res.idExchShort]->getBid(); double limPriceLong = getLimitPrice[res.idExchLong](params, volumeLong, false); double limPriceShort = getLimitPrice[res.idExchShort](params, volumeShort, true); if (limPriceLong - res.priceLongIn > params.priceDeltaLim || res.priceShortIn - limPriceShort > params.priceDeltaLim) { logFile << "WARNING: Opportunity found but not enough liquidity. Trade canceled" << std::endl; logFile << " Target long price: " << res.priceLongIn << ", Real long price: " << limPriceLong << std::endl; logFile << " Target short price: " << res.priceShortIn << ", Real short price: " << limPriceShort << std::endl; res.trailing[res.idExchLong][res.idExchShort] = -1.0; break; } inMarket = true; resultId++; // update result res.id = resultId; res.entryTime = currTime; res.priceLongIn = limPriceLong; res.priceShortIn = limPriceShort; res.printEntry(*params.logFile); res.maxSpread[res.idExchLong][res.idExchShort] = -1.0; res.minSpread[res.idExchLong][res.idExchShort] = 1.0; res.trailing[res.idExchLong][res.idExchShort] = 1.0; int longOrderId = 0; int shortOrderId = 0; // send orders longOrderId = sendOrder[res.idExchLong](params, "buy", volumeLong, btcVec[res.idExchLong]->getAsk()); shortOrderId = sendOrder[res.idExchShort](params, "sell", volumeShort, btcVec[res.idExchShort]->getBid()); // wait for the orders to be filled logFile << "Waiting for the two orders to be filled..." << std::endl; sleep(3.0); while (!isOrderComplete[res.idExchLong](params, longOrderId) || !isOrderComplete[res.idExchShort](params, shortOrderId)) { sleep(3.0); } logFile << "Done" << std::endl; longOrderId = 0; shortOrderId = 0; break; } } } if (inMarket) { break; } } if (params.verbose) { logFile << std::endl; } } // in market, looking to exit else if (inMarket) { if (checkExit(btcVec[res.idExchLong], btcVec[res.idExchShort], res, params, currTime)) { // exit opportunity found // check current exposure double* btcUsed = (double*)malloc(sizeof(double) * num_exchange); for (int i = 0; i < num_exchange; ++i) { btcUsed[i] = getActivePos[i](params); } double volumeLong = btcUsed[res.idExchLong]; double volumeShort = btcUsed[res.idExchShort]; double limPriceLong = getLimitPrice[res.idExchLong](params, volumeLong, true); double limPriceShort = getLimitPrice[res.idExchShort](params, volumeShort, false); if (res.priceLongOut - limPriceLong > params.priceDeltaLim || limPriceShort - res.priceShortOut > params.priceDeltaLim) { logFile << "WARNING: Opportunity found but not enough liquidity. Trade canceled" << std::endl; logFile << " Target long price: " << res.priceLongOut << ", Real long price: " << limPriceLong << std::endl; logFile << " Target short price: " << res.priceShortOut << ", Real short price: " << limPriceShort << std::endl; res.trailing[res.idExchLong][res.idExchShort] = 1.0; } else { res.exitTime = currTime; res.priceLongOut = limPriceLong; res.priceShortOut = limPriceShort; res.printExit(*params.logFile); int longOrderId = 0; int shortOrderId = 0; logFile << std::setprecision(6) << "BTC exposure on " << params.exchName[res.idExchLong] << ": " << volumeLong << std::setprecision(2) << std::endl; logFile << std::setprecision(6) << "BTC exposure on " << params.exchName[res.idExchShort] << ": " << volumeShort << std::setprecision(2) << std::endl; logFile << std::endl; // send orders longOrderId = sendOrder[res.idExchLong](params, "sell", fabs(btcUsed[res.idExchLong]), btcVec[res.idExchLong]->getBid()); shortOrderId = sendOrder[res.idExchShort](params, "buy", fabs(btcUsed[res.idExchShort]), btcVec[res.idExchShort]->getAsk()); // wait for the orders to be filled logFile << "Waiting for the two orders to be filled..." << std::endl; sleep(3.0); while (!isOrderComplete[res.idExchLong](params, longOrderId) || !isOrderComplete[res.idExchShort](params, shortOrderId)) { sleep(3.0); } logFile << "Done\n" << std::endl; longOrderId = 0; shortOrderId = 0; inMarket = false; // new balances for (int i = 0; i < num_exchange; ++i) { newBalUsd[i] = getAvail[i](params, "usd"); newBalBtc[i] = getAvail[i](params, "btc"); } for (int i = 0; i < num_exchange; ++i) { logFile << "New balance on " << params.exchName[i] << ": \t"; logFile << newBalUsd[i] << " USD (perf $" << newBalUsd[i] - balanceUsd[i] << "), "; logFile << std::setprecision(6) << newBalBtc[i] << std::setprecision(2) << " BTC" << std::endl; } logFile << std::endl; // update res with total balance for (int i = 0; i < num_exchange; ++i) { res.befBalUsd += balanceUsd[i]; res.aftBalUsd += newBalUsd[i]; } // update current balances with new values for (int i = 0; i < num_exchange; ++i) { balanceUsd[i] = newBalUsd[i]; balanceBtc[i] = newBalBtc[i]; } logFile << "ACTUAL PERFORMANCE: " << "$" << res.aftBalUsd - res.befBalUsd << " (" << res.totPerf() * 100.0 << "%)\n" << std::endl; csvFile << res.id << "," << res.exchNameLong << "," << res.exchNameShort << "," << printDateTimeCsv(res.entryTime) << "," << printDateTimeCsv(res.exitTime); csvFile << "," << res.getLength() << "," << res.exposure * 2.0 << "," << res.befBalUsd << "," << res.aftBalUsd << "," << res.totPerf() << "\n"; csvFile.flush(); if (params.sendEmail) { sendEmail(res, params); logFile << "Email sent" << std::endl; } res.clear(); std::ifstream infile("stop_after_exit"); if (infile.good()) { logFile << "Exit after last trade (file stop_after_exit found)" << std::endl; stillRunning = false; } } } if (params.verbose) { logFile << std::endl; } } timeinfo->tm_sec = timeinfo->tm_sec + params.gapSec; currIteration++; if (currIteration >= params.debugMaxIteration) { logFile << "Max iteration reached (" << params.debugMaxIteration << ")" <<std::endl; stillRunning = false; } } for (int i = 0; i < num_exchange; ++i) { delete(btcVec[i]); } curl_easy_cleanup(params.curl); curl_global_cleanup(); if (params.useDatabase) { mysql_close(params.dbConn); } csvFile.close(); logFile.close(); return 0; }
/* * Source code in here hugely as reported in bug report 651464 by * Christopher R. Palmer. * * Use multi interface to get document over proxy with bad port number. * This caused the interface to "hang" in libcurl 7.10.2. */ int test(char *URL) { CURL *c; int ret=0; CURLM *m; fd_set rd, wr, exc; CURLMcode res; char done = FALSE; int running; int max_fd; int rc; struct timeval ml_start; struct timeval mp_start; char ml_timedout = FALSE; char mp_timedout = FALSE; if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) { fprintf(stderr, "curl_global_init() failed\n"); return TEST_ERR_MAJOR_BAD; } if ((c = curl_easy_init()) == NULL) { fprintf(stderr, "curl_easy_init() failed\n"); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } /* the point here being that there must not run anything on the given proxy port */ curl_easy_setopt(c, CURLOPT_PROXY, arg2); curl_easy_setopt(c, CURLOPT_URL, URL); curl_easy_setopt(c, CURLOPT_VERBOSE, 1); if ((m = curl_multi_init()) == NULL) { fprintf(stderr, "curl_multi_init() failed\n"); curl_easy_cleanup(c); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } if ((res = curl_multi_add_handle(m, c)) != CURLM_OK) { fprintf(stderr, "curl_multi_add_handle() failed, " "with code %d\n", res); curl_multi_cleanup(m); curl_easy_cleanup(c); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } ml_timedout = FALSE; ml_start = tutil_tvnow(); while (!done) { struct timeval interval; interval.tv_sec = 1; interval.tv_usec = 0; if (tutil_tvdiff(tutil_tvnow(), ml_start) > MAIN_LOOP_HANG_TIMEOUT) { ml_timedout = TRUE; break; } mp_timedout = FALSE; mp_start = tutil_tvnow(); fprintf(stderr, "curl_multi_perform()\n"); res = CURLM_CALL_MULTI_PERFORM; while (res == CURLM_CALL_MULTI_PERFORM) { res = curl_multi_perform(m, &running); if (tutil_tvdiff(tutil_tvnow(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) { mp_timedout = TRUE; break; } } if (mp_timedout) break; if(!running) { /* This is where this code is expected to reach */ int numleft; CURLMsg *msg = curl_multi_info_read(m, &numleft); fprintf(stderr, "Expected: not running\n"); if(msg && !numleft) ret = 100; /* this is where we should be */ else ret = 99; /* not correct */ break; } fprintf(stderr, "running == %d, res == %d\n", running, res); if (res != CURLM_OK) { ret = 2; break; } FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&exc); max_fd = 0; fprintf(stderr, "curl_multi_fdset()\n"); if (curl_multi_fdset(m, &rd, &wr, &exc, &max_fd) != CURLM_OK) { fprintf(stderr, "unexpected failured of fdset.\n"); ret = 3; break; } rc = select_test(max_fd+1, &rd, &wr, &exc, &interval); fprintf(stderr, "select returned %d\n", rc); } if (ml_timedout || mp_timedout) { if (ml_timedout) fprintf(stderr, "ml_timedout\n"); if (mp_timedout) fprintf(stderr, "mp_timedout\n"); fprintf(stderr, "ABORTING TEST, since it seems " "that it would have run forever.\n"); ret = TEST_ERR_RUNS_FOREVER; } curl_multi_remove_handle(m, c); curl_easy_cleanup(c); curl_multi_cleanup(m); curl_global_cleanup(); return ret; }
//------------------------------------------------------------------------------ // helper function to terminate Kraken API library's resources: void terminate() { curl_global_cleanup(); }
int main(int argc, char **argv) { CURL *curl; CURLcode res; FILE *ftpfile; FILE * hd_src ; int hd ; struct stat file_info; struct curl_slist *headerlist=NULL; char buf_1 [] = "RNFR " UPLOAD_FILE_AS; char buf_2 [] = "RNTO " RENAME_FILE_TO; /* get the file size of the local file */ hd = open(LOCAL_FILE, O_RDONLY) ; fstat(hd, &file_info); close(hd) ; /* get a FILE * of the same file, could also be made with fdopen() from the previous descriptor, but hey this is just an example! */ hd_src = fopen(LOCAL_FILE, "rb"); /* In windows, this will init the winsock stuff */ curl_global_init(CURL_GLOBAL_ALL); /* get a curl handle */ curl = curl_easy_init(); if(curl) { /* build a list of commands to pass to libcurl */ // headerlist = curl_slist_append(headerlist, buf_1); // headerlist = curl_slist_append(headerlist, buf_2); /* enable uploading */ curl_easy_setopt(curl, CURLOPT_UPLOAD, TRUE) ; /* set user name and password */ curl_easy_setopt(curl, CURLOPT_USERPWD, "rutul:topspin"); /* specify target */ curl_easy_setopt(curl,CURLOPT_URL, REMOTE_URL); /* pass in that last of FTP commands to run after the transfer */ // curl_easy_setopt(curl, CURLOPT_POSTQUOTE, headerlist); /* now specify which file to upload */ curl_easy_setopt(curl, CURLOPT_INFILE, hd_src); /* and give the size of the upload (optional) */ curl_easy_setopt(curl, CURLOPT_INFILESIZE, file_info.st_size); /* Switch on full protocol/debug output */ curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE); /* Now run off and do what you've been told! */ res = curl_easy_perform(curl); /* clean up the FTP commands list */ curl_slist_free_all (headerlist); /* always cleanup */ curl_easy_cleanup(curl); } fclose(hd_src); /* close the local file */ curl_global_cleanup(); return 0; }
int test(char *URL) { int res = 0; CURL *curl; int running; char done=FALSE; CURLM *m = NULL; struct timeval ml_start; struct timeval mp_start; char ml_timedout = FALSE; char mp_timedout = FALSE; if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) { fprintf(stderr, "curl_global_init() failed\n"); return TEST_ERR_MAJOR_BAD; } if ((curl = curl_easy_init()) == NULL) { fprintf(stderr, "curl_easy_init() failed\n"); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } test_setopt(curl, CURLOPT_URL, URL); test_setopt(curl, CURLOPT_VERBOSE, 1); test_setopt(curl, CURLOPT_PROXY, libtest_arg2); test_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4); if ((m = curl_multi_init()) == NULL) { fprintf(stderr, "curl_multi_init() failed\n"); curl_easy_cleanup(curl); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } if ((res = (int)curl_multi_add_handle(m, curl)) != CURLM_OK) { fprintf(stderr, "curl_multi_add_handle() failed, " "with code %d\n", res); curl_multi_cleanup(m); curl_easy_cleanup(curl); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } ml_timedout = FALSE; ml_start = tutil_tvnow(); fprintf(stderr, "Start at URL 0\n"); while (!done) { fd_set rd, wr, exc; int max_fd; struct timeval interval; interval.tv_sec = 1; interval.tv_usec = 0; if (tutil_tvdiff(tutil_tvnow(), ml_start) > MAIN_LOOP_HANG_TIMEOUT) { ml_timedout = TRUE; break; } mp_timedout = FALSE; mp_start = tutil_tvnow(); while (res == CURLM_CALL_MULTI_PERFORM) { res = (int)curl_multi_perform(m, &running); if (tutil_tvdiff(tutil_tvnow(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) { mp_timedout = TRUE; break; } if (running <= 0) { done = TRUE; /* bail out */ break; } } if (mp_timedout || done) break; if (res != CURLM_OK) { fprintf(stderr, "not okay???\n"); break; } FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&exc); max_fd = 0; if (curl_multi_fdset(m, &rd, &wr, &exc, &max_fd) != CURLM_OK) { fprintf(stderr, "unexpected failured of fdset.\n"); res = 189; break; } if (select_test(max_fd+1, &rd, &wr, &exc, &interval) == -1) { fprintf(stderr, "bad select??\n"); res = 195; break; } res = CURLM_CALL_MULTI_PERFORM; } if (ml_timedout || mp_timedout) { if (ml_timedout) fprintf(stderr, "ml_timedout\n"); if (mp_timedout) fprintf(stderr, "mp_timedout\n"); fprintf(stderr, "ABORTING TEST, since it seems " "that it would have run forever.\n"); res = TEST_ERR_RUNS_FOREVER; } test_cleanup: curl_easy_cleanup(curl); if(m) curl_multi_cleanup(m); curl_global_cleanup(); return res; }
JNIEXPORT void JNICALL Java_com_netbirdtech_libcurl_Curl_curlGlobalCleanupNative (JNIEnv * env, jclass cls) { curl_global_cleanup(); }
int test(char *URL) { CURL* curls; CURLM* multi; int still_running; int i = -1; int res = 0; CURLMsg *msg; CURLMcode ret; struct timeval ml_start; struct timeval mp_start; char ml_timedout = FALSE; char mp_timedout = FALSE; if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) { fprintf(stderr, "curl_global_init() failed\n"); return TEST_ERR_MAJOR_BAD; } if ((multi = curl_multi_init()) == NULL) { fprintf(stderr, "curl_multi_init() failed\n"); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } if ((curls = curl_easy_init()) == NULL) { fprintf(stderr, "curl_easy_init() failed\n"); curl_multi_cleanup(multi); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } test_setopt(curls, CURLOPT_URL, URL); if ((ret = curl_multi_add_handle(multi, curls)) != CURLM_OK) { fprintf(stderr, "curl_multi_add_handle() failed, " "with code %d\n", ret); curl_easy_cleanup(curls); curl_multi_cleanup(multi); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } mp_timedout = FALSE; mp_start = tutil_tvnow(); do { ret = curl_multi_perform(multi, &still_running); if (tutil_tvdiff(tutil_tvnow(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) { mp_timedout = TRUE; break; } } while (ret == CURLM_CALL_MULTI_PERFORM); ml_timedout = FALSE; ml_start = tutil_tvnow(); while ((!ml_timedout) && (!mp_timedout) && (still_running)) { struct timeval timeout; int rc; fd_set fdread; fd_set fdwrite; fd_set fdexcep; int maxfd; FD_ZERO(&fdread); FD_ZERO(&fdwrite); FD_ZERO(&fdexcep); timeout.tv_sec = 1; timeout.tv_usec = 0; if (tutil_tvdiff(tutil_tvnow(), ml_start) > MAIN_LOOP_HANG_TIMEOUT) { ml_timedout = TRUE; break; } curl_multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd); rc = select_test(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout); switch(rc) { case -1: break; case 0: default: mp_timedout = FALSE; mp_start = tutil_tvnow(); do { ret = curl_multi_perform(multi, &still_running); if (tutil_tvdiff(tutil_tvnow(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) { mp_timedout = TRUE; break; } } while (ret == CURLM_CALL_MULTI_PERFORM); break; } } if (ml_timedout || mp_timedout) { if (ml_timedout) fprintf(stderr, "ml_timedout\n"); if (mp_timedout) fprintf(stderr, "mp_timedout\n"); fprintf(stderr, "ABORTING TEST, since it seems " "that it would have run forever.\n"); i = TEST_ERR_RUNS_FOREVER; } else { msg = curl_multi_info_read(multi, &still_running); if(msg) /* this should now contain a result code from the easy handle, get it */ i = msg->data.result; } test_cleanup: curl_multi_cleanup(multi); curl_easy_cleanup(curls); curl_global_cleanup(); if(res) i = res; return i; /* return the final return code */ }
int test(char *URL) { int res; CURL *curl; int request=1; char *stream_uri = NULL; if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) { fprintf(stderr, "curl_global_init() failed\n"); return TEST_ERR_MAJOR_BAD; } if ((curl = curl_easy_init()) == NULL) { fprintf(stderr, "curl_easy_init() failed\n"); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } test_setopt(curl, CURLOPT_HEADERDATA, stdout); test_setopt(curl, CURLOPT_WRITEDATA, stdout); test_setopt(curl, CURLOPT_VERBOSE, 1L); test_setopt(curl, CURLOPT_URL, URL); test_setopt(curl, CURLOPT_RTSP_REQUEST, CURL_RTSPREQ_OPTIONS); if((stream_uri = suburl(URL, request++)) == NULL) { res = TEST_ERR_MAJOR_BAD; goto test_cleanup; } test_setopt(curl, CURLOPT_RTSP_STREAM_URI, stream_uri); free(stream_uri); stream_uri = NULL; res = curl_easy_perform(curl); if(res != (int)CURLE_RTSP_CSEQ_ERROR) { fprintf(stderr, "Failed to detect CSeq mismatch"); res = TEST_ERR_MAJOR_BAD; goto test_cleanup; } test_setopt(curl, CURLOPT_RTSP_CLIENT_CSEQ, 999); test_setopt(curl, CURLOPT_RTSP_TRANSPORT, "RAW/RAW/UDP;unicast;client_port=3056-3057"); test_setopt(curl, CURLOPT_RTSP_REQUEST, CURL_RTSPREQ_SETUP); if((stream_uri = suburl(URL, request++)) == NULL) { res = TEST_ERR_MAJOR_BAD; goto test_cleanup; } test_setopt(curl, CURLOPT_RTSP_STREAM_URI, stream_uri); free(stream_uri); stream_uri = NULL; res = curl_easy_perform(curl); if(res) goto test_cleanup; test_setopt(curl, CURLOPT_RTSP_REQUEST, CURL_RTSPREQ_PLAY); if((stream_uri = suburl(URL, request++)) == NULL) { res = TEST_ERR_MAJOR_BAD; goto test_cleanup; } test_setopt(curl, CURLOPT_RTSP_STREAM_URI, stream_uri); free(stream_uri); stream_uri = NULL; res = curl_easy_perform(curl); if(res != CURLE_RTSP_SESSION_ERROR) { fprintf(stderr, "Failed to detect a Session ID mismatch"); } test_cleanup: if(stream_uri) free(stream_uri); curl_easy_cleanup(curl); curl_global_cleanup(); return res; }
int main(int argc, char* argv[]) { for(int i=1; i<argc; ++i) { if(strcmp(argv[i], "-help") == 0) { print_usage(); return -1; } else if(strcmp(argv[i], "-nocontent") == 0) { bNoOutContent = true; } else if(strcmp(argv[i], "-status") == 0) { bOutHttpStatus = true; } else if(strcmp(argv[i], "-head") == 0) { bOutHeader = true; } else if(strcmp(argv[i], "-useragent") == 0) { ++i; if(i < argc) szUserAgent = argv[i]; else { print_usage(); return -1; } } else { szUrl = argv[i]; } } CURLcode retCode = CURLE_OK; RET_CURL(curl_global_init, CURL_GLOBAL_ALL); pstCURLHandle = curl_easy_init(); if(pstCURLHandle == NULL) { printf("error[%s:%d]: create CURL handle fail.\n", __FILE__, __LINE__); return -1; } RET_CURL(curl_easy_setopt, pstCURLHandle, CURLOPT_HEADER, 0); RET_CURL(curl_easy_setopt, pstCURLHandle, CURLOPT_WRITEFUNCTION, HttpWriteCallback); RET_CURL(curl_easy_setopt, pstCURLHandle, CURLOPT_HEADERFUNCTION, HttpHeaderCallback); if(szUserAgent != NULL) RET_CURL(curl_easy_setopt, pstCURLHandle, CURLOPT_USERAGENT, szUserAgent); if(szUrl == NULL) { char buffer[4097]; int size = 0; int len = 4096; int offset = 0; memset(buffer, 0, 4097); while(-1 != (size = read(STDIN_FILENO, buffer + offset, len))) { if(size == 0) break; char* pStart = buffer; char* pEnd = NULL; while((pEnd = strchr(pStart, '\n')) != NULL) { pEnd[0] = 0x0; RET_CURL(curl_easy_setopt, pstCURLHandle, CURLOPT_URL, pStart); RET_CURL(curl_easy_perform, pstCURLHandle); pStart = pEnd + 1; } strcpy(buffer, pStart); offset = strlen(pStart); len = 4096 - offset; memset(buffer + offset, 0, len); } } else { RET_CURL(curl_easy_setopt, pstCURLHandle, CURLOPT_URL, szUrl); RET_CURL(curl_easy_perform, pstCURLHandle); if(bOutHttpStatus) { boost::regex rgxHttpStatus("^HTTP/([^ ]+) ([0-9]+)"); boost::smatch what; if(boost::regex_search(strHeader, what, rgxHttpStatus)) printf("%d\n", atoi(what[2].str().c_str())); else printf("500\n"); } if(bOutHeader) printf("%s", strHeader.c_str()); if(!bNoOutContent) printf("%s", strContent.c_str()); } curl_easy_cleanup(pstCURLHandle); curl_global_cleanup(); return 0; }
int test(char *URL) { int res = 0; CURLM *m = NULL; CURLMsg *msg; /* for picking up messages with the transfer status */ int msgs_left; /* how many messages are left */ int running; int handlenum = 0; struct timeval last_handle_add; if(parse_url_file("log/urls.txt") <= 0) goto test_cleanup; start_test_timing(); curl_global_init(CURL_GLOBAL_ALL); m = curl_multi_init(); create_handles(); multi_setopt(m, CURLMOPT_PIPELINING, 1L); multi_setopt(m, CURLMOPT_MAX_HOST_CONNECTIONS, 2L); multi_setopt(m, CURLMOPT_MAX_PIPELINE_LENGTH, 3L); multi_setopt(m, CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, 15000L); multi_setopt(m, CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, 10000L); multi_setopt(m, CURLMOPT_PIPELINING_SITE_BL, site_blacklist); multi_setopt(m, CURLMOPT_PIPELINING_SERVER_BL, server_blacklist); last_handle_add = tutil_tvnow(); for(;;) { struct timeval interval; struct timeval now; long int msnow, mslast; fd_set rd, wr, exc; int maxfd = -99; long timeout; interval.tv_sec = 1; interval.tv_usec = 0; if(handlenum < num_handles) { now = tutil_tvnow(); msnow = now.tv_sec * 1000 + now.tv_usec / 1000; mslast = last_handle_add.tv_sec * 1000 + last_handle_add.tv_usec / 1000; if(msnow - mslast >= urltime[handlenum] && handlenum < num_handles) { fprintf(stdout, "Adding handle %d\n", handlenum); setup_handle(URL, m, handlenum); last_handle_add = now; handlenum++; } } curl_multi_perform(m, &running); abort_on_test_timeout(); /* See how the transfers went */ while ((msg = curl_multi_info_read(m, &msgs_left))) { if (msg->msg == CURLMSG_DONE) { int i, found = 0; /* Find out which handle this message is about */ for (i = 0; i < num_handles; i++) { found = (msg->easy_handle == handles[i]); if(found) break; } printf("Handle %d Completed with status %d\n", i, msg->data.result); curl_multi_remove_handle(m, handles[i]); } } if(handlenum == num_handles && !running) { break; /* done */ } FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&exc); curl_multi_fdset(m, &rd, &wr, &exc, &maxfd); /* At this point, maxfd is guaranteed to be greater or equal than -1. */ curl_multi_timeout(m, &timeout); if(timeout < 0) timeout = 1; interval.tv_sec = timeout / 1000; interval.tv_usec = (timeout % 1000) * 1000; interval.tv_sec = 0; interval.tv_usec = 1000; select_test(maxfd+1, &rd, &wr, &exc, &interval); abort_on_test_timeout(); } test_cleanup: remove_handles(); /* undocumented cleanup sequence - type UB */ curl_multi_cleanup(m); curl_global_cleanup(); free_urls(); return res; }
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow) { PF_CONSOLE_INIT_ALL() // Set global handle gHInst = hInst; std::vector<plString> args; args.reserve(__argc); for (size_t i = 0; i < __argc; i++) { args.push_back(plString::FromUtf8(__argv[i])); } plCmdParser cmdParser(s_cmdLineArgs, arrsize(s_cmdLineArgs)); cmdParser.Parse(args); bool doIntroDialogs = true; #ifndef PLASMA_EXTERNAL_RELEASE if (cmdParser.IsSpecified(kArgSkipLoginDialog)) doIntroDialogs = false; if (cmdParser.IsSpecified(kArgLocalData)) { gDataServerLocal = true; gSkipPreload = true; } if (cmdParser.IsSpecified(kArgSkipPreload)) gSkipPreload = true; if (cmdParser.IsSpecified(kArgPlayerId)) NetCommSetIniPlayerId(cmdParser.GetInt(kArgPlayerId)); if (cmdParser.IsSpecified(kArgStartUpAgeName)) NetCommSetIniStartUpAge(cmdParser.GetString(kArgStartUpAgeName)); #endif plFileName serverIni = "server.ini"; if (cmdParser.IsSpecified(kArgServerIni)) serverIni = cmdParser.GetString(kArgServerIni); // check to see if we were launched from the patcher bool eventExists = false; // we check to see if the event exists that the patcher should have created HANDLE hPatcherEvent = CreateEventW(nil, TRUE, FALSE, L"UruPatcherEvent"); if (hPatcherEvent != NULL) { // successfully created it, check to see if it was already created if (GetLastError() == ERROR_ALREADY_EXISTS) { // it already existed, so the patcher is waiting, signal it so the patcher can die SetEvent(hPatcherEvent); eventExists = true; } } #ifdef PLASMA_EXTERNAL_RELEASE // if the client was started directly, run the patcher, and shutdown STARTUPINFOW si; PROCESS_INFORMATION pi; memset(&si, 0, sizeof(si)); memset(&pi, 0, sizeof(pi)); si.cb = sizeof(si); if (!eventExists) // if it is missing, assume patcher wasn't launched { if(!CreateProcessW(s_patcherExeName, NULL, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) { hsMessageBox("Failed to launch patcher", "Error", hsMessageBoxNormal); } CloseHandle( pi.hThread ); CloseHandle( pi.hProcess ); return PARABLE_NORMAL_EXIT; } #endif // Load an optional general.ini plFileName gipath = plFileName::Join(plFileSystem::GetInitPath(), "general.ini"); FILE *generalini = plFileSystem::Open(gipath, "rb"); if (generalini) { fclose(generalini); pfConsoleEngine tempConsole; tempConsole.ExecuteFile(gipath); } #ifdef PLASMA_EXTERNAL_RELEASE // If another instance is running, exit. We'll automatically release our // lock on the mutex when our process exits HANDLE hOneInstance = CreateMutex(nil, FALSE, "UruExplorer"); if (WaitForSingleObject(hOneInstance,0) != WAIT_OBJECT_0) { switch (plLocalization::GetLanguage()) { case plLocalization::kFrench: hsMessageBox("Une autre copie d'URU est déjà en cours d'exécution", "Erreur", hsMessageBoxNormal); break; case plLocalization::kGerman: hsMessageBox("URU wird bereits in einer anderen Instanz ausgeführt", "Fehler", hsMessageBoxNormal); break; case plLocalization::kSpanish: hsMessageBox("En estos momentos se está ejecutando otra copia de URU", "Error", hsMessageBoxNormal); break; case plLocalization::kItalian: hsMessageBox("Un'altra copia di URU è già aperta", "Errore", hsMessageBoxNormal); break; // default is English default: hsMessageBox("Another copy of URU is already running", "Error", hsMessageBoxNormal); break; } return PARABLE_NORMAL_EXIT; } #endif FILE *serverIniFile = plFileSystem::Open(serverIni, "rb"); if (serverIniFile) { fclose(serverIniFile); pfConsoleEngine tempConsole; tempConsole.ExecuteFile(serverIni); } else { hsMessageBox("No server.ini file found. Please check your URU installation.", "Error", hsMessageBoxNormal); return PARABLE_NORMAL_EXIT; } NetCliAuthAutoReconnectEnable(false); InitNetClientComm(); curl_global_init(CURL_GLOBAL_ALL); bool needExit = false; LoginDialogParam loginParam; memset(&loginParam, 0, sizeof(loginParam)); LoadUserPass(&loginParam); if (!doIntroDialogs && loginParam.remember) { ENetError auth; NetCommSetAccountUsernamePassword(loginParam.username, loginParam.namePassHash); bool cancelled = AuthenticateNetClientComm(&auth, NULL); if (IS_NET_ERROR(auth) || cancelled) { doIntroDialogs = true; loginParam.authError = auth; if (cancelled) { NetCommDisconnect(); } } } if (doIntroDialogs) { needExit = ::DialogBoxParam( hInst, MAKEINTRESOURCE( IDD_URULOGIN_MAIN ), NULL, UruLoginDialogProc, (LPARAM)&loginParam ) <= 0; } if (doIntroDialogs && !needExit) { HINSTANCE hRichEdDll = LoadLibrary("RICHED20.DLL"); INT_PTR val = ::DialogBoxParam( hInst, MAKEINTRESOURCE( IDD_URULOGIN_EULA ), NULL, UruTOSDialogProc, (LPARAM)hInst); FreeLibrary(hRichEdDll); if (val <= 0) { DWORD error = GetLastError(); needExit = true; } } curl_global_cleanup(); if (needExit) { DeInitNetClientComm(); return PARABLE_NORMAL_EXIT; } NetCliAuthAutoReconnectEnable(true); // VERY VERY FIRST--throw up our splash screen HWND splashDialog = ::CreateDialog( hInst, MAKEINTRESOURCE( IDD_LOADING ), NULL, SplashDialogProc ); // Install our unhandled exception filter for trapping all those nasty crashes in release build #ifndef HS_DEBUGGING LPTOP_LEVEL_EXCEPTION_FILTER oldFilter; oldFilter = SetUnhandledExceptionFilter( plCustomUnhandledExceptionFilter ); #endif // // Set up to log errors by using hsDebugMessage // DebugInit(); DebugMsgF("Plasma 2.0.%i.%i - %s", PLASMA2_MAJOR_VERSION, PLASMA2_MINOR_VERSION, plProduct::ProductString().c_str()); for (;;) { // Create Window if (!WinInit(hInst, nCmdShow) || gClient->GetDone()) break; // Done with our splash now ::DestroyWindow( splashDialog ); if (!gClient) break; // Show the main window ShowWindow(gClient->GetWindowHandle(), SW_SHOW); // Be really REALLY forceful about being in the front BringWindowToTop( gClient->GetWindowHandle() ); // Update the window UpdateWindow(gClient->GetWindowHandle()); // // Init Application here // if( !gClient->StartInit() ) break; // I want it on top! I mean it! BringWindowToTop( gClient->GetWindowHandle() ); // initialize dinput here: if (gClient && gClient->GetInputManager()) gClient->GetInputManager()->InitDInput(hInst, (HWND)gClient->GetWindowHandle()); // Seriously! BringWindowToTop( gClient->GetWindowHandle() ); // // Main loop // MSG msg; do { gClient->MainLoop(); if( gClient->GetDone() ) break; // Look for a message while (PeekMessage( &msg, NULL, 0, 0, PM_REMOVE )) { // Handle the message TranslateMessage( &msg ); DispatchMessage( &msg ); } } while (WM_QUIT != msg.message); break; } // // Cleanup // if (gClient) { gClient->Shutdown(); // shuts down PhysX for us gClient = nil; } hsAssert(hsgResMgr::ResMgr()->RefCnt()==1, "resMgr has too many refs, expect mem leaks"); hsgResMgr::Shutdown(); // deletes fResMgr DeInitNetClientComm(); // Uninstall our unhandled exception filter, if we installed one #ifndef HS_DEBUGGING SetUnhandledExceptionFilter( oldFilter ); #endif // Exit WinMain and terminate the app.... return PARABLE_NORMAL_EXIT; }
CurlDownloadManager::~CurlDownloadManager() { stopThread(); curl_multi_cleanup(m_curlMultiHandle); curl_global_cleanup(); }
/* test function */ int test(char *URL) { int res; CURLSHcode scode; char *url; struct Tdata tdata; CURL *curl; CURLSH *share; struct curl_slist *headers; int i; struct userdata user; user.text = (char *)"Pigs in space"; user.counter = 0; printf( "GLOBAL_INIT\n" ); curl_global_init( CURL_GLOBAL_ALL ); /* prepare share */ printf( "SHARE_INIT\n" ); share = curl_share_init(); curl_share_setopt( share, CURLSHOPT_LOCKFUNC, lock); curl_share_setopt( share, CURLSHOPT_UNLOCKFUNC, unlock); curl_share_setopt( share, CURLSHOPT_USERDATA, &user); printf( "CURL_LOCK_DATA_COOKIE\n" ); curl_share_setopt( share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE); printf( "CURL_LOCK_DATA_DNS\n" ); curl_share_setopt( share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS); res = 0; /* start treads */ for (i=1; i<=THREADS; i++ ) { /* set thread data */ tdata.url = suburl( URL, i ); /* must be freed */ tdata.share = share; /* simulate thread, direct call of "thread" function */ printf( "*** run %d\n",i ); fire( &tdata ); free( tdata.url ); } /* fetch a another one and save cookies */ printf( "*** run %d\n", i ); curl = curl_easy_init(); url = suburl( URL, i ); headers = sethost( NULL ); curl_easy_setopt( curl, CURLOPT_HTTPHEADER, (void*)headers ); curl_easy_setopt( curl, CURLOPT_URL, url ); printf( "CURLOPT_SHARE\n" ); curl_easy_setopt( curl, CURLOPT_SHARE, share ); printf( "CURLOPT_COOKIEJAR\n" ); curl_easy_setopt( curl, CURLOPT_COOKIEJAR, JAR ); printf( "PERFORM\n" ); curl_easy_perform( curl ); /* try to free share, expect to fail because share is in use*/ printf( "try SHARE_CLEANUP...\n" ); scode = curl_share_cleanup( share ); if ( scode==CURLSHE_OK ) { fprintf(stderr, "curl_share_cleanup succeed but error expected\n"); share = NULL; } else { printf( "SHARE_CLEANUP failed, correct\n" ); } /* clean up last handle */ printf( "CLEANUP\n" ); curl_easy_cleanup( curl ); curl_slist_free_all( headers ); free(url); /* free share */ printf( "SHARE_CLEANUP\n" ); scode = curl_share_cleanup( share ); if ( scode!=CURLSHE_OK ) { fprintf(stderr, "curl_share_cleanup failed, code errno %d\n", scode); } printf( "GLOBAL_CLEANUP\n" ); curl_global_cleanup(); return res; }
int free_internet() { if (curlHnd != NULL) curl_easy_cleanup(curlHnd); curl_global_cleanup(); return 0; }
void moloch_http_exit() { curl_global_cleanup(); }
ConsulRestClient::~ConsulRestClient() { curl_global_cleanup(); }
~CurlInit() { curl_global_cleanup(); }
/* test function */ int test(char *URL) { int res; CURLSHcode scode = CURLSHE_OK; char *url = NULL; struct Tdata tdata; CURL *curl; CURLSH *share; struct curl_slist *headers = NULL; int i; struct userdata user; user.text = (char *)"Pigs in space"; user.counter = 0; printf( "GLOBAL_INIT\n" ); if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) { fprintf(stderr, "curl_global_init() failed\n"); return TEST_ERR_MAJOR_BAD; } /* prepare share */ printf( "SHARE_INIT\n" ); if ((share = curl_share_init()) == NULL) { fprintf(stderr, "curl_share_init() failed\n"); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } if ( CURLSHE_OK == scode ) { printf( "CURLSHOPT_LOCKFUNC\n" ); scode = curl_share_setopt( share, CURLSHOPT_LOCKFUNC, my_lock); } if ( CURLSHE_OK == scode ) { printf( "CURLSHOPT_UNLOCKFUNC\n" ); scode = curl_share_setopt( share, CURLSHOPT_UNLOCKFUNC, my_unlock); } if ( CURLSHE_OK == scode ) { printf( "CURLSHOPT_USERDATA\n" ); scode = curl_share_setopt( share, CURLSHOPT_USERDATA, &user); } if ( CURLSHE_OK == scode ) { printf( "CURL_LOCK_DATA_COOKIE\n" ); scode = curl_share_setopt( share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE); } if ( CURLSHE_OK == scode ) { printf( "CURL_LOCK_DATA_DNS\n" ); scode = curl_share_setopt( share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS); } if ( CURLSHE_OK != scode ) { fprintf(stderr, "curl_share_setopt() failed\n"); curl_share_cleanup(share); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } /* initial cookie manipulation */ if ((curl = curl_easy_init()) == NULL) { fprintf(stderr, "curl_easy_init() failed\n"); curl_share_cleanup(share); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } printf( "CURLOPT_SHARE\n" ); test_setopt( curl, CURLOPT_SHARE, share ); printf( "CURLOPT_COOKIELIST injected_and_clobbered\n" ); test_setopt( curl, CURLOPT_COOKIELIST, "Set-Cookie: injected_and_clobbered=yes; " "domain=host.foo.com; expires=Sat Feb 2 11:56:27 GMT 2030" ); printf( "CURLOPT_COOKIELIST ALL\n" ); test_setopt( curl, CURLOPT_COOKIELIST, "ALL" ); printf( "CURLOPT_COOKIELIST session\n" ); test_setopt( curl, CURLOPT_COOKIELIST, "Set-Cookie: session=elephants" ); printf( "CURLOPT_COOKIELIST injected\n" ); test_setopt( curl, CURLOPT_COOKIELIST, "Set-Cookie: injected=yes; domain=host.foo.com; " "expires=Sat Feb 2 11:56:27 GMT 2030" ); printf( "CURLOPT_COOKIELIST SESS\n" ); test_setopt( curl, CURLOPT_COOKIELIST, "SESS" ); printf( "CLEANUP\n" ); curl_easy_cleanup( curl ); res = 0; /* start treads */ for (i=1; i<=THREADS; i++ ) { /* set thread data */ tdata.url = suburl( URL, i ); /* must be curl_free()d */ tdata.share = share; /* simulate thread, direct call of "thread" function */ printf( "*** run %d\n",i ); fire( &tdata ); curl_free( tdata.url ); } /* fetch a another one and save cookies */ printf( "*** run %d\n", i ); if ((curl = curl_easy_init()) == NULL) { fprintf(stderr, "curl_easy_init() failed\n"); curl_share_cleanup(share); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } url = suburl( URL, i ); headers = sethost( NULL ); test_setopt( curl, CURLOPT_HTTPHEADER, headers ); test_setopt( curl, CURLOPT_URL, url ); printf( "CURLOPT_SHARE\n" ); test_setopt( curl, CURLOPT_SHARE, share ); printf( "CURLOPT_COOKIEJAR\n" ); test_setopt( curl, CURLOPT_COOKIEJAR, JAR ); printf( "CURLOPT_COOKIELIST FLUSH\n" ); test_setopt( curl, CURLOPT_COOKIELIST, "FLUSH" ); printf( "PERFORM\n" ); curl_easy_perform( curl ); /* try to free share, expect to fail because share is in use*/ printf( "try SHARE_CLEANUP...\n" ); scode = curl_share_cleanup( share ); if ( scode==CURLSHE_OK ) { fprintf(stderr, "curl_share_cleanup succeed but error expected\n"); share = NULL; } else { printf( "SHARE_CLEANUP failed, correct\n" ); } test_cleanup: /* clean up last handle */ printf( "CLEANUP\n" ); curl_easy_cleanup( curl ); if ( headers ) curl_slist_free_all( headers ); if ( url ) curl_free(url); /* free share */ printf( "SHARE_CLEANUP\n" ); scode = curl_share_cleanup( share ); if ( scode!=CURLSHE_OK ) fprintf(stderr, "curl_share_cleanup failed, code errno %d\n", (int)scode); printf( "GLOBAL_CLEANUP\n" ); curl_global_cleanup(); return res; }
void CommandDispatcher (int32_t pProcNum, sLONG_PTR *pResult, PackagePtr pParams) { switch(pProcNum) { case kInitPlugin : curl_global_init(CURL_GLOBAL_ALL); break; case kDeinitPlugin : curl_global_cleanup(); break; // --- PKCS case 1 : PEM_From_P12(pResult, pParams); break; // --- MISC case 2 : PICTURE_GET_RAW_DATA(pResult, pParams); break; case 3 : STACK_Get_available_size(pResult, pParams); break; case 4 : PROCESS_GET_LIST(pResult, pParams); break; case 5 : PROCESS_Get_id(pResult, pParams); break; case 6 : SYSTEM_Get_timestamp(pResult, pParams); break; case 7 : SYSTEM_Get_timestring(pResult, pParams); break; case 8 : SYSTEM_Generate_UUID(pResult, pParams); break; case 9 : SYSTEM_Get_unixtime(pResult, pParams); break; case 10 : STRUCTURE_Import_definition(pResult, pParams); break; case 11 : VOLUME_Is_remote(pResult, pParams); break; case 12 : VOLUME_Is_ejectable(pResult, pParams); break; case 13 : PATH_Get_known_folder(pResult, pParams); break; case 14 : PATH_From_user_selection(pResult, pParams); break; // --- JSON case 15 : JSON_Strip_white_space(pResult, pParams); break; case 16 : JSON_Parse_text(pResult, pParams); break; case 17 : JSON_Export_to_text(pResult, pParams); break; case 18 : JSON_CLOSE(pResult, pParams); break; case 19 : JSON_New(pResult, pParams); break; case 20 : JSON_GET_BOOL_ARRAY(pResult, pParams); break; case 21 : JSON_GET_CHILD_NODES(pResult, pParams); break; case 22 : JSON_GET_LONG_ARRAY(pResult, pParams); break; case 23 : JSON_Get_child_by_name(pResult, pParams); break; case 24 : JSON_Get_child_by_position(pResult, pParams); break; case 25 : JSON_Get_comment(pResult, pParams); break; case 26 : JSON_GET_TEXT_ARRAY(pResult, pParams); break; case 27 : JSON_GET_REAL_ARRAY(pResult, pParams); break; case 28 : JSON_Get_bool(pResult, pParams); break; case 29 : JSON_Get_real(pResult, pParams); break; case 30 : JSON_Get_long(pResult, pParams); break; case 31 : JSON_Get_type(pResult, pParams); break; case 32 : JSON_Get_name(pResult, pParams); break; case 33 : JSON_Get_text(pResult, pParams); break; case 34 : JSON_DELETE_ITEM_BY_NAME(pResult, pParams); break; case 35 : JSON_DELETE_ITEM_BY_POSITION(pResult, pParams); break; case 36 : JSON_SET_TYPE(pResult, pParams); break; case 37 : JSON_SET_NULL(pResult, pParams); break; case 38 : JSON_SET_COMMENT(pResult, pParams); break; case 39 : JSON_SET_NAME(pResult, pParams); break; case 40 : JSON_SET_TEXT(pResult, pParams); break; case 41 : JSON_SET_LONG(pResult, pParams); break; case 42 : JSON_SET_REAL(pResult, pParams); break; case 43 : JSON_Append_bool_array(pResult, pParams); break; case 44 : JSON_Append_real_array(pResult, pParams); break; case 45 : JSON_Append_long_array(pResult, pParams); break; case 46 : JSON_Append_text_array(pResult, pParams); break; case 47 : JSON_Append_text(pResult, pParams); break; case 48 : JSON_Append_long(pResult, pParams); break; case 49 : JSON_Append_real(pResult, pParams); break; case 50 : JSON_Append_bool(pResult, pParams); break; case 51 : JSON_Append_node(pResult, pParams); break; case 52 : JSON_SET_BOOL(pResult, pParams); break; case 53 : JSON_CLEAR(pResult, pParams); break; // --- ZIP case 54 : Unzip(pResult, pParams); break; case 55 : Zip(pResult, pParams); break; // --- Common Crypto case 56 : RSASHA256(pResult, pParams); break; case 57 : HMACMD5(pResult, pParams); break; case 58 : HMACSHA1(pResult, pParams); break; case 59 : HMACSHA256(pResult, pParams); break; case 60 : HMACSHA384(pResult, pParams); break; case 61 : HMACSHA512(pResult, pParams); break; case 62 : SHA384(pResult, pParams); break; case 63 : SHA512(pResult, pParams); break; case 64 : MD5(pResult, pParams); break; case 65 : SHA1(pResult, pParams); break; case 66 : SHA256(pResult, pParams); break; // --- cURL case 67 : _cURL(pResult, pParams); break; case 68 : cURL_Escape_url(pResult, pParams); break; case 69 : cURL_Unescape_url(pResult, pParams); break; case 70 : cURL_Get_version(pResult, pParams); break; case 71 : cURL_Get_date(pResult, pParams); break; } }
int test(char *URL) { int res = 0; CURL *curl[NUM_HANDLES]; int running; char done=FALSE; CURLM *m; int i, j; struct timeval ml_start; struct timeval mp_start; char ml_timedout = FALSE; char mp_timedout = FALSE; char target_url[256]; if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) { fprintf(stderr, "curl_global_init() failed\n"); return TEST_ERR_MAJOR_BAD; } if ((m = curl_multi_init()) == NULL) { fprintf(stderr, "curl_multi_init() failed\n"); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } /* get NUM_HANDLES easy handles */ for(i=0; i < NUM_HANDLES; i++) { curl[i] = curl_easy_init(); if(!curl[i]) { fprintf(stderr, "curl_easy_init() failed " "on handle #%d\n", i); for (j=i-1; j >= 0; j--) { curl_multi_remove_handle(m, curl[j]); curl_easy_cleanup(curl[j]); } curl_multi_cleanup(m); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD + i; } sprintf(target_url, "%s%04i", URL, i + 1); target_url[sizeof(target_url) - 1] = '\0'; res = curl_easy_setopt(curl[i], CURLOPT_URL, target_url); if(res) { fprintf(stderr, "curl_easy_setopt() failed " "on handle #%d\n", i); for (j=i; j >= 0; j--) { curl_multi_remove_handle(m, curl[j]); curl_easy_cleanup(curl[j]); } curl_multi_cleanup(m); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD + i; } /* go verbose */ res = curl_easy_setopt(curl[i], CURLOPT_VERBOSE, 1L); if(res) { fprintf(stderr, "curl_easy_setopt() failed " "on handle #%d\n", i); for (j=i; j >= 0; j--) { curl_multi_remove_handle(m, curl[j]); curl_easy_cleanup(curl[j]); } curl_multi_cleanup(m); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD + i; } /* include headers */ res = curl_easy_setopt(curl[i], CURLOPT_HEADER, 1L); if(res) { fprintf(stderr, "curl_easy_setopt() failed " "on handle #%d\n", i); for (j=i; j >= 0; j--) { curl_multi_remove_handle(m, curl[j]); curl_easy_cleanup(curl[j]); } curl_multi_cleanup(m); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD + i; } /* add handle to multi */ if ((res = (int)curl_multi_add_handle(m, curl[i])) != CURLM_OK) { fprintf(stderr, "curl_multi_add_handle() failed, " "on handle #%d with code %d\n", i, res); curl_easy_cleanup(curl[i]); for (j=i-1; j >= 0; j--) { curl_multi_remove_handle(m, curl[j]); curl_easy_cleanup(curl[j]); } curl_multi_cleanup(m); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD + i; } } curl_multi_setopt(m, CURLMOPT_PIPELINING, 1L); ml_timedout = FALSE; ml_start = tutil_tvnow(); fprintf(stderr, "Start at URL 0\n"); while (!done) { fd_set rd, wr, exc; int max_fd; struct timeval interval; interval.tv_sec = 1; interval.tv_usec = 0; if (tutil_tvdiff(tutil_tvnow(), ml_start) > MAIN_LOOP_HANG_TIMEOUT) { ml_timedout = TRUE; break; } mp_timedout = FALSE; mp_start = tutil_tvnow(); while (res == CURLM_CALL_MULTI_PERFORM) { res = (int)curl_multi_perform(m, &running); if (tutil_tvdiff(tutil_tvnow(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) { mp_timedout = TRUE; break; } if (running <= 0) { done = TRUE; /* bail out */ break; } } if (mp_timedout || done) break; if (res != CURLM_OK) { fprintf(stderr, "not okay???\n"); break; } FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&exc); max_fd = 0; if (curl_multi_fdset(m, &rd, &wr, &exc, &max_fd) != CURLM_OK) { fprintf(stderr, "unexpected failured of fdset.\n"); res = 189; break; } if (select_test(max_fd+1, &rd, &wr, &exc, &interval) == -1) { fprintf(stderr, "bad select??\n"); res = 195; break; } res = CURLM_CALL_MULTI_PERFORM; } if (ml_timedout || mp_timedout) { if (ml_timedout) fprintf(stderr, "ml_timedout\n"); if (mp_timedout) fprintf(stderr, "mp_timedout\n"); fprintf(stderr, "ABORTING TEST, since it seems " "that it would have run forever.\n"); res = TEST_ERR_RUNS_FOREVER; } /* test_cleanup: */ /* cleanup NUM_HANDLES easy handles */ for(i=0; i < NUM_HANDLES; i++) { curl_multi_remove_handle(m, curl[i]); curl_easy_cleanup(curl[i]); } curl_multi_cleanup(m); curl_global_cleanup(); return res; }
void QBox_Global_Cleanup() { curl_global_cleanup(); }
void CWebTV::processPlaylistUrl(const char *url, const char *name, const char * description) { dprintf(DEBUG_DEBUG, "CWebTV::processPlaylistUrl\n"); CURL *curl_handle; struct MemoryStruct chunk; chunk.memory = NULL; /* we expect realloc(NULL, size) to work */ chunk.size = 0; /* no data at this point */ curl_global_init(CURL_GLOBAL_ALL); /* init the curl session */ curl_handle = curl_easy_init(); /* specify URL to get */ curl_easy_setopt(curl_handle, CURLOPT_URL, url); /* send all data to this function */ curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); /* we pass our 'chunk' struct to the callback function */ curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk); /* some servers don't like requests that are made without a user-agent field, so we provide one */ curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0"); /* don't use signal for timeout */ curl_easy_setopt(curl_handle, CURLOPT_NOSIGNAL, (long)1); /* set timeout to 10 seconds */ curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, 10); if(strcmp(g_settings.softupdate_proxyserver, "")!=0) { curl_easy_setopt(curl_handle, CURLOPT_PROXY, g_settings.softupdate_proxyserver); if(strcmp(g_settings.softupdate_proxyusername, "") != 0) { char tmp[200]; strcpy(tmp, g_settings.softupdate_proxyusername); strcat(tmp, ":"); strcat(tmp, g_settings.softupdate_proxypassword); curl_easy_setopt(curl_handle, CURLOPT_PROXYUSERPWD, tmp); } } /* get it! */ curl_easy_perform(curl_handle); /* cleanup curl stuff */ curl_easy_cleanup(curl_handle); /* * Now, our chunk.memory points to a memory block that is chunk.size * bytes big and contains the remote file. * * Do something nice with it! * * You should be aware of the fact that at this point we might have an * allocated data block, and nothing has yet deallocated that data. So when * you're done with it, you should free() it as a nice application. */ long res_code; if (curl_easy_getinfo(curl_handle, CURLINFO_HTTP_CODE, &res_code ) == CURLE_OK) { if (200 == res_code) { //printf("\nchunk = %s\n", chunk.memory); std::istringstream iss; iss.str (std::string(chunk.memory, chunk.size)); char line[512]; char *ptr; while (iss.rdstate() == std::ifstream::goodbit) { iss.getline(line, 512); if (line[0] != '#') { //printf("chunk: line = %s\n", line); ptr = strstr(line, "http://"); if (ptr != NULL) { char *tmp; // strip \n and \r characters from url tmp = strchr(line, '\r'); if (tmp != NULL) *tmp = '\0'; tmp = strchr(line, '\n'); if (tmp != NULL) *tmp = '\0'; addUrl2Playlist(ptr, name, description); } } } } } if(chunk.memory) free(chunk.memory); /* we're done with libcurl, so clean it up */ curl_global_cleanup(); }