* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
uses */
curl_multi_setopt(cm, CURLMOPT_MAXCONNECTS, (long)MAX);
- for (C = 0; C < MAX; ++C) {
+ for(C = 0; C < MAX; ++C) {
init(cm, C);
}
- while (U) {
+ while(U) {
curl_multi_perform(cm, &U);
- if (U) {
+ if(U) {
FD_ZERO(&R);
FD_ZERO(&W);
FD_ZERO(&E);
- if (curl_multi_fdset(cm, &R, &W, &E, &M)) {
+ if(curl_multi_fdset(cm, &R, &W, &E, &M)) {
fprintf(stderr, "E: curl_multi_fdset\n");
return EXIT_FAILURE;
}
- if (curl_multi_timeout(cm, &L)) {
+ if(curl_multi_timeout(cm, &L)) {
fprintf(stderr, "E: curl_multi_timeout\n");
return EXIT_FAILURE;
}
- if (L == -1)
+ if(L == -1)
L = 100;
- if (M == -1) {
+ if(M == -1) {
#ifdef WIN32
Sleep(L);
#else
sleep(L / 1000);
#endif
- } else {
+ }
+ else {
T.tv_sec = L/1000;
T.tv_usec = (L%1000)*1000;
- if (0 > select(M+1, &R, &W, &E, &T)) {
+ if(0 > select(M+1, &R, &W, &E, &T)) {
fprintf(stderr, "E: select(%i,,,,%li): %i: %s\n",
M+1, L, errno, strerror(errno));
return EXIT_FAILURE;
}
}
- while ((msg = curl_multi_info_read(cm, &Q))) {
- if (msg->msg == CURLMSG_DONE) {
+ while((msg = curl_multi_info_read(cm, &Q))) {
+ if(msg->msg == CURLMSG_DONE) {
char *url;
CURL *e = msg->easy_handle;
curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &url);
else {
fprintf(stderr, "E: CURLMsg (%d)\n", msg->msg);
}
- if (C < CNT) {
+ if(C < CNT) {
init(cm, C++);
U++; /* just to prevent it from remaining at 0 if there are more
URLs to get */
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
{
CURL *curl;
CURLcode res;
- intptr_t hd ;
+ intptr_t hd;
struct stat file_info;
char *file;
url = argv[2];
/* get the file size of the local file */
- hd = open(file, O_RDONLY) ;
+ hd = open(file, O_RDONLY);
fstat(hd, &file_info);
/* In windows, this will init the winsock stuff */
curl_easy_setopt(curl, CURLOPT_IOCTLDATA, (void*)hd);
/* enable "uploading" (which means PUT when doing HTTP) */
- curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L) ;
+ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
/* specify target URL, and note that this URL should also include a file
name, not only a directory (as you can do with GTP uploads) */
- curl_easy_setopt(curl,CURLOPT_URL, url);
+ curl_easy_setopt(curl, CURLOPT_URL, url);
/* and give the size of the upload, this supports large file sizes
on systems that have general support for it */
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
size_t writefunction( void *ptr, size_t size, size_t nmemb, void *stream)
{
- fwrite(ptr,size,nmemb,stream);
- return(nmemb*size);
+ fwrite(ptr, size, nmemb, stream);
+ return (nmemb*size);
}
static CURLcode sslctx_function(CURL * curl, void * sslctx, void * parm)
* structure that SSL can use
*/
PEM_read_bio_X509(bio, &cert, 0, NULL);
- if (cert == NULL)
+ if(cert == NULL)
printf("PEM_read_bio_X509 failed...\n");
/* get a pointer to the X509 certificate store (which may be empty!) */
store=SSL_CTX_get_cert_store((SSL_CTX *)sslctx);
/* add our certificate to this store */
- if (X509_STORE_add_cert(store, cert)==0)
+ if(X509_STORE_add_cert(store, cert)==0)
printf("error adding certificate\n");
/* decrease reference counts */
BIO_free(bio);
/* all set to go */
- return CURLE_OK ;
+ return CURLE_OK;
}
int main(void)
rv=curl_global_init(CURL_GLOBAL_ALL);
ch=curl_easy_init();
- rv=curl_easy_setopt(ch,CURLOPT_VERBOSE, 0L);
- rv=curl_easy_setopt(ch,CURLOPT_HEADER, 0L);
- rv=curl_easy_setopt(ch,CURLOPT_NOPROGRESS, 1L);
- rv=curl_easy_setopt(ch,CURLOPT_NOSIGNAL, 1L);
- rv=curl_easy_setopt(ch,CURLOPT_WRITEFUNCTION, *writefunction);
- rv=curl_easy_setopt(ch,CURLOPT_WRITEDATA, stdout);
- rv=curl_easy_setopt(ch,CURLOPT_HEADERFUNCTION, *writefunction);
- rv=curl_easy_setopt(ch,CURLOPT_HEADERDATA, stderr);
- rv=curl_easy_setopt(ch,CURLOPT_SSLCERTTYPE,"PEM");
- rv=curl_easy_setopt(ch,CURLOPT_SSL_VERIFYPEER,1L);
+ rv=curl_easy_setopt(ch, CURLOPT_VERBOSE, 0L);
+ rv=curl_easy_setopt(ch, CURLOPT_HEADER, 0L);
+ rv=curl_easy_setopt(ch, CURLOPT_NOPROGRESS, 1L);
+ rv=curl_easy_setopt(ch, CURLOPT_NOSIGNAL, 1L);
+ rv=curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, *writefunction);
+ rv=curl_easy_setopt(ch, CURLOPT_WRITEDATA, stdout);
+ rv=curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, *writefunction);
+ rv=curl_easy_setopt(ch, CURLOPT_HEADERDATA, stderr);
+ rv=curl_easy_setopt(ch, CURLOPT_SSLCERTTYPE, "PEM");
+ rv=curl_easy_setopt(ch, CURLOPT_SSL_VERIFYPEER, 1L);
rv=curl_easy_setopt(ch, CURLOPT_URL, "https://www.example.com/");
/* first try: retrieve page without cacerts' certificate -> will fail
*/
rv=curl_easy_perform(ch);
- if (rv==CURLE_OK)
+ if(rv==CURLE_OK)
printf("*** transfer succeeded ***\n");
else
printf("*** transfer failed ***\n");
* load the certificate by installing a function doing the nescessary
* "modifications" to the SSL CONTEXT just before link init
*/
- rv=curl_easy_setopt(ch,CURLOPT_SSL_CTX_FUNCTION, *sslctx_function);
+ rv=curl_easy_setopt(ch, CURLOPT_SSL_CTX_FUNCTION, *sslctx_function);
rv=curl_easy_perform(ch);
- if (rv==CURLE_OK)
+ if(rv==CURLE_OK)
printf("*** transfer succeeded ***\n");
else
printf("*** transfer failed ***\n");
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
const char *url = URL_1M;
char *appname = argv[0];
- if (argc > 1) {
+ if(argc > 1) {
/* parse input parameters */
- for (argc--, argv++; *argv; argc--, argv++) {
- if (strncasecmp(*argv, "-", 1) == 0) {
- if (strncasecmp(*argv, "-H", 2) == 0) {
+ for(argc--, argv++; *argv; argc--, argv++) {
+ if(strncasecmp(*argv, "-", 1) == 0) {
+ if(strncasecmp(*argv, "-H", 2) == 0) {
fprintf(stderr,
"\rUsage: %s [-m=1|2|5|10|20|50|100] [-t] [-x] [url]\n",
appname);
exit(1);
- } else if (strncasecmp(*argv, "-V", 2) == 0) {
+ }
+ else if(strncasecmp(*argv, "-V", 2) == 0) {
fprintf(stderr, "\r%s %s - %s\n",
appname, CHKSPEED_VERSION, curl_version());
exit(1);
- } else if (strncasecmp(*argv, "-A", 2) == 0) {
+ }
+ else if(strncasecmp(*argv, "-A", 2) == 0) {
prtall = 1;
- } else if (strncasecmp(*argv, "-X", 2) == 0) {
+ }
+ else if(strncasecmp(*argv, "-X", 2) == 0) {
prtsep = 1;
- } else if (strncasecmp(*argv, "-T", 2) == 0) {
+ }
+ else if(strncasecmp(*argv, "-T", 2) == 0) {
prttime = 1;
- } else if (strncasecmp(*argv, "-M=", 3) == 0) {
+ }
+ else if(strncasecmp(*argv, "-M=", 3) == 0) {
long m = strtol((*argv)+3, NULL, 10);
switch(m) {
- case 1: url = URL_1M;
- break;
- case 2: url = URL_2M;
- break;
- case 5: url = URL_5M;
- break;
- case 10: url = URL_10M;
- break;
- case 20: url = URL_20M;
- break;
- case 50: url = URL_50M;
- break;
- case 100: url = URL_100M;
- break;
- default: fprintf(stderr, "\r%s: invalid parameter %s\n",
- appname, *argv + 3);
- exit(1);
+ case 1:
+ url = URL_1M;
+ break;
+ case 2:
+ url = URL_2M;
+ break;
+ case 5:
+ url = URL_5M;
+ break;
+ case 10:
+ url = URL_10M;
+ break;
+ case 20:
+ url = URL_20M;
+ break;
+ case 50:
+ url = URL_50M;
+ break;
+ case 100:
+ url = URL_100M;
+ break;
+ default:
+ fprintf(stderr, "\r%s: invalid parameter %s\n",
+ appname, *argv + 3);
+ exit(1);
}
- } else {
+ }
+ else {
fprintf(stderr, "\r%s: invalid or unknown option %s\n",
appname, *argv);
exit(1);
}
- } else {
+ }
+ else {
url = *argv;
}
}
}
/* print separator line */
- if (prtsep) {
+ if(prtsep) {
printf("-------------------------------------------------\n");
}
/* print localtime */
- if (prttime) {
+ if(prttime) {
time_t t = time(NULL);
printf("Localtime: %s", ctime(&t));
}
if((CURLE_OK == res) && (val>0))
printf("Average download speed: %0.3f kbyte/sec.\n", val / 1024);
- if (prtall) {
+ if(prtall) {
/* check for name resolution time */
res = curl_easy_getinfo(curl_handle, CURLINFO_NAMELOOKUP_TIME, &val);
if((CURLE_OK == res) && (val>0))
if((CURLE_OK == res) && (val>0))
printf("Connect time: %0.3f sec.\n", val);
}
-
- } else {
+ }
+ else {
fprintf(stderr, "Error while fetching '%s' : %s\n",
url, curl_easy_strerror(res));
}
printf("Cookies, curl knows:\n");
res = curl_easy_getinfo(curl, CURLINFO_COOKIELIST, &cookies);
- if (res != CURLE_OK) {
+ if(res != CURLE_OK) {
fprintf(stderr, "Curl curl_easy_getinfo failed: %s\n",
curl_easy_strerror(res));
exit(1);
}
nc = cookies, i = 1;
- while (nc) {
+ while(nc) {
printf("[%d]: %s\n", i, nc->data);
nc = nc->next;
i++;
}
- if (i == 1) {
+ if(i == 1) {
printf("(none)\n");
}
curl_slist_free_all(cookies);
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
- if (curl) {
+ if(curl) {
char nline[256];
curl_easy_setopt(curl, CURLOPT_URL, "http://www.example.com/");
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, ""); /* start cookie engine */
res = curl_easy_perform(curl);
- if (res != CURLE_OK) {
+ if(res != CURLE_OK) {
fprintf(stderr, "Curl perform failed: %s\n", curl_easy_strerror(res));
return 1;
}
(unsigned long)time(NULL) + 31337UL,
"PREF", "hello google, i like you very much!");
res = curl_easy_setopt(curl, CURLOPT_COOKIELIST, nline);
- if (res != CURLE_OK) {
+ if(res != CURLE_OK) {
fprintf(stderr, "Curl curl_easy_setopt failed: %s\n",
curl_easy_strerror(res));
return 1;
"Set-Cookie: OLD_PREF=3d141414bf4209321; "
"expires=Sun, 17-Jan-2038 19:14:07 GMT; path=/; domain=.google.com");
res = curl_easy_setopt(curl, CURLOPT_COOKIELIST, nline);
- if (res != CURLE_OK) {
+ if(res != CURLE_OK) {
fprintf(stderr, "Curl curl_easy_setopt failed: %s\n",
curl_easy_strerror(res));
return 1;
print_cookies(curl);
res = curl_easy_perform(curl);
- if (res != CURLE_OK) {
+ if(res != CURLE_OK) {
fprintf(stderr, "Curl perform failed: %s\n", curl_easy_strerror(res));
return 1;
}
gchar *url = ptr;
curl = curl_easy_init();
- if(curl)
- {
- outfile = fopen("test.curl", "w");
+ if(curl) {
+ const char *filename = "test.curl";
+ outfile = fopen(filename, "wb");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, outfile);
gtk_container_add(GTK_CONTAINER(Frame2), Bar);
gtk_widget_show_all(Window);
- if (!g_thread_create(&my_thread, argv[1], FALSE, NULL) != 0)
+ if(!g_thread_create(&my_thread, argv[1], FALSE, NULL) != 0)
g_warning("can't create the thread");
static const char *curlx_usage[]={
"usage: curlx args\n",
" -p12 arg - tia file ",
- " -envpass arg - environement variable which content the tia private key password",
+ " -envpass arg - environement variable which content the tia private"
+ " key password",
" -out arg - output file (response)- default stdout",
" -in arg - input file (request)- default stdin",
- " -connect arg - URL of the server for the connection ex: www.openevidence.org",
- " -mimetype arg - MIME type for data in ex : application/timestamp-query or application/dvcs -default application/timestamp-query",
- " -acceptmime arg - MIME type acceptable for the response ex : application/timestamp-response or application/dvcs -default none",
- " -accesstype arg - an Object identifier in an AIA/SIA method, e.g. AD_DVCS or ad_timestamping",
+ " -connect arg - URL of the server for the connection ex:"
+ " www.openevidence.org",
+ " -mimetype arg - MIME type for data in ex : application/timestamp-query"
+ " or application/dvcs -default application/timestamp-query",
+ " -acceptmime arg - MIME type acceptable for the response ex : "
+ "application/timestamp-response or application/dvcs -default none",
+ " -accesstype arg - an Object identifier in an AIA/SIA method, e.g."
+ " AD_DVCS or ad_timestamping",
NULL
};
/* This is a context that we pass to all callbacks */
typedef struct sslctxparm_st {
- unsigned char * p12file ;
- const char * pst ;
- PKCS12 * p12 ;
- EVP_PKEY * pkey ;
- X509 * usercert ;
- STACK_OF(X509) * ca ;
+ unsigned char * p12file;
+ const char * pst;
+ PKCS12 * p12;
+ EVP_PKEY * pkey;
+ X509 * usercert;
+ STACK_OF(X509) * ca;
CURL * curl;
BIO * errorbio;
- int accesstype ;
+ int accesstype;
int verbose;
} sslctxparm;
}
/* A conveniance routine to get an access URI. */
-
-static unsigned char *my_get_ext(X509 * cert, const int type, int extensiontype) {
-
+static unsigned char *my_get_ext(X509 * cert, const int type,
+ int extensiontype)
+{
int i;
- STACK_OF(ACCESS_DESCRIPTION) * accessinfo ;
- accessinfo = X509_get_ext_d2i(cert, extensiontype, NULL, NULL) ;
+ STACK_OF(ACCESS_DESCRIPTION) * accessinfo;
+ accessinfo = X509_get_ext_d2i(cert, extensiontype, NULL, NULL);
- if (!sk_ACCESS_DESCRIPTION_num(accessinfo))
+ if(!sk_ACCESS_DESCRIPTION_num(accessinfo))
return NULL;
- for (i = 0; i < sk_ACCESS_DESCRIPTION_num(accessinfo); i++) {
+ for(i = 0; i < sk_ACCESS_DESCRIPTION_num(accessinfo); i++) {
ACCESS_DESCRIPTION * ad = sk_ACCESS_DESCRIPTION_value(accessinfo, i);
- if (OBJ_obj2nid(ad->method) == type) {
- if (ad->location->type == GEN_URI) {
+ if(OBJ_obj2nid(ad->method) == type) {
+ if(ad->location->type == GEN_URI) {
return i2s_ASN1_IA5STRING(ad->location->d.ia5);
}
return NULL;
sslctxparm * p = (sslctxparm *) arg;
int ok;
- if (p->verbose > 2)
- BIO_printf(p->errorbio,"entering ssl_app_verify_callback\n");
+ if(p->verbose > 2)
+ BIO_printf(p->errorbio, "entering ssl_app_verify_callback\n");
- if ((ok= X509_verify_cert(ctx)) && ctx->cert) {
- unsigned char * accessinfo ;
- if (p->verbose > 1)
- X509_print_ex(p->errorbio,ctx->cert,0,0);
+ if((ok= X509_verify_cert(ctx)) && ctx->cert) {
+ unsigned char * accessinfo;
+ if(p->verbose > 1)
+ X509_print_ex(p->errorbio, ctx->cert, 0, 0);
- if (accessinfo = my_get_ext(ctx->cert,p->accesstype ,NID_sinfo_access)) {
- if (p->verbose)
- BIO_printf(p->errorbio,"Setting URL from SIA to: %s\n", accessinfo);
+ if(accessinfo = my_get_ext(ctx->cert, p->accesstype, NID_sinfo_access)) {
+ if(p->verbose)
+ BIO_printf(p->errorbio, "Setting URL from SIA to: %s\n", accessinfo);
- curl_easy_setopt(p->curl, CURLOPT_URL,accessinfo);
+ curl_easy_setopt(p->curl, CURLOPT_URL, accessinfo);
}
- else if (accessinfo = my_get_ext(ctx->cert,p->accesstype,
- NID_info_access)) {
- if (p->verbose)
- BIO_printf(p->errorbio,"Setting URL from AIA to: %s\n", accessinfo);
+ else if(accessinfo = my_get_ext(ctx->cert, p->accesstype,
+ NID_info_access)) {
+ if(p->verbose)
+ BIO_printf(p->errorbio, "Setting URL from AIA to: %s\n", accessinfo);
- curl_easy_setopt(p->curl, CURLOPT_URL,accessinfo);
+ curl_easy_setopt(p->curl, CURLOPT_URL, accessinfo);
}
}
- if (p->verbose > 2)
- BIO_printf(p->errorbio,"leaving ssl_app_verify_callback with %d\n", ok);
- return(ok);
+ if(p->verbose > 2)
+ BIO_printf(p->errorbio, "leaving ssl_app_verify_callback with %d\n", ok);
+
+ return ok;
}
-/* This is an example of an curl SSL initialisation call back. The callback sets:
+/* The SSL initialisation callback. The callback sets:
- a private key and certificate
- a trusted ca certificate
- a preferred cipherlist
static CURLcode sslctxfun(CURL * curl, void * sslctx, void * parm) {
sslctxparm * p = (sslctxparm *) parm;
- SSL_CTX * ctx = (SSL_CTX *) sslctx ;
+ SSL_CTX * ctx = (SSL_CTX *) sslctx;
- if (!SSL_CTX_use_certificate(ctx,p->usercert)) {
- BIO_printf(p->errorbio, "SSL_CTX_use_certificate problem\n"); goto err;
+ if(!SSL_CTX_use_certificate(ctx, p->usercert)) {
+ BIO_printf(p->errorbio, "SSL_CTX_use_certificate problem\n");
+ goto err;
}
- if (!SSL_CTX_use_PrivateKey(ctx,p->pkey)) {
- BIO_printf(p->errorbio, "SSL_CTX_use_PrivateKey\n"); goto err;
+ if(!SSL_CTX_use_PrivateKey(ctx, p->pkey)) {
+ BIO_printf(p->errorbio, "SSL_CTX_use_PrivateKey\n");
+ goto err;
}
- if (!SSL_CTX_check_private_key(ctx)) {
- BIO_printf(p->errorbio, "SSL_CTX_check_private_key\n"); goto err;
+ if(!SSL_CTX_check_private_key(ctx)) {
+ BIO_printf(p->errorbio, "SSL_CTX_check_private_key\n");
+ goto err;
}
- SSL_CTX_set_quiet_shutdown(ctx,1);
- SSL_CTX_set_cipher_list(ctx,"RC4-MD5");
+ SSL_CTX_set_quiet_shutdown(ctx, 1);
+ SSL_CTX_set_cipher_list(ctx, "RC4-MD5");
SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
- X509_STORE_add_cert(SSL_CTX_get_cert_store(ctx), sk_X509_value(p->ca, sk_X509_num(p->ca)-1));
+ X509_STORE_add_cert(SSL_CTX_get_cert_store(ctx),
+ sk_X509_value(p->ca, sk_X509_num(p->ca)-1));
- SSL_CTX_set_verify_depth(ctx,2);
+ SSL_CTX_set_verify_depth(ctx, 2);
- SSL_CTX_set_verify(ctx,SSL_VERIFY_PEER,ZERO_NULL);
+ SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, ZERO_NULL);
SSL_CTX_set_cert_verify_callback(ctx, ssl_app_verify_callback, parm);
- return CURLE_OK ;
+ return CURLE_OK;
err:
ERR_print_errors(p->errorbio);
return CURLE_SSL_CERTPROBLEM;
BIO* out=NULL;
char * outfile = NULL;
- char * infile = NULL ;
+ char * infile = NULL;
int tabLength=100;
char *binaryptr;
char* contenttype;
const char** pp;
unsigned char* hostporturl = NULL;
- BIO * p12bio ;
+ BIO * p12bio;
char **args = argv + 1;
unsigned char * serverurl;
sslctxparm p;
- while (*args && *args[0] == '-') {
- if (!strcmp (*args, "-in")) {
- if (args[1]) {
+ while(*args && *args[0] == '-') {
+ if(!strcmp (*args, "-in")) {
+ if(args[1]) {
infile=*(++args);
- } else badarg=1;
- } else if (!strcmp (*args, "-out")) {
- if (args[1]) {
+ }
+ else
+ badarg=1;
+ }
+ else if(!strcmp (*args, "-out")) {
+ if(args[1]) {
outfile=*(++args);
- } else badarg=1;
- } else if (!strcmp (*args, "-p12")) {
- if (args[1]) {
+ }
+ else
+ badarg=1;
+ }
+ else if(!strcmp (*args, "-p12")) {
+ if(args[1]) {
p.p12file = *(++args);
- } else badarg=1;
- } else if (strcmp(*args,"-envpass") == 0) {
- if (args[1]) {
+ }
+ else
+ badarg=1;
+ }
+ else if(strcmp(*args, "-envpass") == 0) {
+ if(args[1]) {
p.pst = getenv(*(++args));
- } else badarg=1;
- } else if (strcmp(*args,"-connect") == 0) {
- if (args[1]) {
+ }
+ else
+ badarg=1;
+ }
+ else if(strcmp(*args, "-connect") == 0) {
+ if(args[1]) {
hostporturl = *(++args);
- } else badarg=1;
- } else if (strcmp(*args,"-mimetype") == 0) {
- if (args[1]) {
+ }
+ else
+ badarg=1;
+ }
+ else if(strcmp(*args, "-mimetype") == 0) {
+ if(args[1]) {
mimetype = *(++args);
- } else badarg=1;
- } else if (strcmp(*args,"-acceptmime") == 0) {
- if (args[1]) {
+ }
+ else
+ badarg=1;
+ }
+ else if(strcmp(*args, "-acceptmime") == 0) {
+ if(args[1]) {
mimetypeaccept = *(++args);
- } else badarg=1;
- } else if (strcmp(*args,"-accesstype") == 0) {
- if (args[1]) {
- if ((p.accesstype = OBJ_obj2nid(OBJ_txt2obj(*++args,0))) == 0) badarg=1;
- } else badarg=1;
- } else if (strcmp(*args,"-verbose") == 0) {
+ }
+ else
+ badarg=1;
+ }
+ else if(strcmp(*args, "-accesstype") == 0) {
+ if(args[1]) {
+ if((p.accesstype = OBJ_obj2nid(OBJ_txt2obj(*++args, 0))) == 0)
+ badarg=1;
+ }
+ else
+ badarg=1;
+ }
+ else if(strcmp(*args, "-verbose") == 0) {
p.verbose++;
- } else badarg=1;
+ }
+ else
+ badarg=1;
args++;
}
- if (mimetype==NULL || mimetypeaccept == NULL) badarg = 1;
+ if(mimetype==NULL || mimetypeaccept == NULL)
+ badarg = 1;
- if (badarg) {
- for (pp=curlx_usage; (*pp != NULL); pp++)
- BIO_printf(p.errorbio,"%s\n",*pp);
- BIO_printf(p.errorbio,"\n");
+ if(badarg) {
+ for(pp=curlx_usage; (*pp != NULL); pp++)
+ BIO_printf(p.errorbio, "%s\n", *pp);
+ BIO_printf(p.errorbio, "\n");
goto err;
}
/* set input */
- if ((in=BIO_new(BIO_s_file())) == NULL) {
+ if((in=BIO_new(BIO_s_file())) == NULL) {
BIO_printf(p.errorbio, "Error setting input bio\n");
goto err;
- } else if (infile == NULL)
- BIO_set_fp(in,stdin,BIO_NOCLOSE|BIO_FP_TEXT);
- else if (BIO_read_filename(in,infile) <= 0) {
+ }
+ else if(infile == NULL)
+ BIO_set_fp(in, stdin, BIO_NOCLOSE|BIO_FP_TEXT);
+ else if(BIO_read_filename(in, infile) <= 0) {
BIO_printf(p.errorbio, "Error opening input file %s\n", infile);
BIO_free(in);
goto err;
/* set output */
- if ((out=BIO_new(BIO_s_file())) == NULL) {
+ if((out=BIO_new(BIO_s_file())) == NULL) {
BIO_printf(p.errorbio, "Error setting output bio.\n");
goto err;
- } else if (outfile == NULL)
- BIO_set_fp(out,stdout,BIO_NOCLOSE|BIO_FP_TEXT);
- else if (BIO_write_filename(out,outfile) <= 0) {
+ }
+ else if(outfile == NULL)
+ BIO_set_fp(out, stdout, BIO_NOCLOSE|BIO_FP_TEXT);
+ else if(BIO_write_filename(out, outfile) <= 0) {
BIO_printf(p.errorbio, "Error opening output file %s\n", outfile);
BIO_free(out);
goto err;
p.errorbio = BIO_new_fp (stderr, BIO_NOCLOSE);
- if (!(p.curl = curl_easy_init())) {
+ if(!(p.curl = curl_easy_init())) {
BIO_printf(p.errorbio, "Cannot init curl lib\n");
goto err;
}
- if (!(p12bio = BIO_new_file(p.p12file , "rb"))) {
- BIO_printf(p.errorbio, "Error opening P12 file %s\n", p.p12file); goto err;
+ if(!(p12bio = BIO_new_file(p.p12file , "rb"))) {
+ BIO_printf(p.errorbio, "Error opening P12 file %s\n", p.p12file);
+ goto err;
}
- if (!(p.p12 = d2i_PKCS12_bio (p12bio, NULL))) {
- BIO_printf(p.errorbio, "Cannot decode P12 structure %s\n", p.p12file); goto err;
+ if(!(p.p12 = d2i_PKCS12_bio (p12bio, NULL))) {
+ BIO_printf(p.errorbio, "Cannot decode P12 structure %s\n", p.p12file);
+ goto err;
}
p.ca= NULL;
- if (!(PKCS12_parse (p.p12, p.pst, &(p.pkey), &(p.usercert), &(p.ca) ) )) {
- BIO_printf(p.errorbio,"Invalid P12 structure in %s\n", p.p12file); goto err;
+ if(!(PKCS12_parse (p.p12, p.pst, &(p.pkey), &(p.usercert), &(p.ca) ) )) {
+ BIO_printf(p.errorbio, "Invalid P12 structure in %s\n", p.p12file);
+ goto err;
}
- if (sk_X509_num(p.ca) <= 0) {
- BIO_printf(p.errorbio,"No trustworthy CA given.%s\n", p.p12file); goto err;
+ if(sk_X509_num(p.ca) <= 0) {
+ BIO_printf(p.errorbio, "No trustworthy CA given.%s\n", p.p12file);
+ goto err;
}
- if (p.verbose > 1)
- X509_print_ex(p.errorbio,p.usercert,0,0);
+ if(p.verbose > 1)
+ X509_print_ex(p.errorbio, p.usercert, 0, 0);
/* determine URL to go */
- if (hostporturl) {
- serverurl = malloc(9+strlen(hostporturl));
- sprintf(serverurl,"https://%s",hostporturl);
+ if(hostporturl) {
+ size_t len = strlen(hostporturl) + 9;
+ serverurl = malloc(len);
+ snprintf(serverurl, len, "https://%s", hostporturl);
}
- else if (p.accesstype != 0) { /* see whether we can find an AIA or SIA for a given access type */
- if (!(serverurl = my_get_ext(p.usercert,p.accesstype,NID_info_access))) {
+ else if(p.accesstype != 0) { /* see whether we can find an AIA or SIA for a
+ given access type */
+ if(!(serverurl = my_get_ext(p.usercert, p.accesstype, NID_info_access))) {
int j=0;
- BIO_printf(p.errorbio,"no service URL in user cert "
+ BIO_printf(p.errorbio, "no service URL in user cert "
"cherching in others certificats\n");
- for (j=0;j<sk_X509_num(p.ca);j++) {
- if ((serverurl = my_get_ext(sk_X509_value(p.ca,j),p.accesstype,
+ for(j=0; j<sk_X509_num(p.ca); j++) {
+ if((serverurl = my_get_ext(sk_X509_value(p.ca, j), p.accesstype,
NID_info_access)))
break;
- if ((serverurl = my_get_ext(sk_X509_value(p.ca,j),p.accesstype,
+ if((serverurl = my_get_ext(sk_X509_value(p.ca, j), p.accesstype,
NID_sinfo_access)))
break;
}
}
}
- if (!serverurl) {
+ if(!serverurl) {
BIO_printf(p.errorbio, "no service URL in certificats,"
" check '-accesstype (AD_DVCS | ad_timestamping)'"
" or use '-connect'\n");
goto err;
}
- if (p.verbose)
+ if(p.verbose)
BIO_printf(p.errorbio, "Service URL: <%s>\n", serverurl);
curl_easy_setopt(p.curl, CURLOPT_URL, serverurl);
/* Now specify the POST binary data */
curl_easy_setopt(p.curl, CURLOPT_POSTFIELDS, binaryptr);
- curl_easy_setopt(p.curl, CURLOPT_POSTFIELDSIZE,(long)tabLength);
+ curl_easy_setopt(p.curl, CURLOPT_POSTFIELDSIZE, (long)tabLength);
/* pass our list of custom made headers */
contenttype = malloc(15+strlen(mimetype));
- sprintf(contenttype,"Content-type: %s",mimetype);
- headers = curl_slist_append(headers,contenttype);
+ snprintf(contenttype, 15+strlen(mimetype), "Content-type: %s", mimetype);
+ headers = curl_slist_append(headers, contenttype);
curl_easy_setopt(p.curl, CURLOPT_HTTPHEADER, headers);
- if (p.verbose)
+ if(p.verbose)
BIO_printf(p.errorbio, "Service URL: <%s>\n", serverurl);
{
FILE *outfp;
- BIO_get_fp(out,&outfp);
+ BIO_get_fp(out, &outfp);
curl_easy_setopt(p.curl, CURLOPT_WRITEDATA, outfp);
}
- res = curl_easy_setopt(p.curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfun) ;
+ res = curl_easy_setopt(p.curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfun);
- if (res != CURLE_OK)
- BIO_printf(p.errorbio,"%d %s=%d %d\n", __LINE__, "CURLOPT_SSL_CTX_FUNCTION",CURLOPT_SSL_CTX_FUNCTION,res);
+ if(res != CURLE_OK)
+ BIO_printf(p.errorbio, "%d %s=%d %d\n", __LINE__,
+ "CURLOPT_SSL_CTX_FUNCTION", CURLOPT_SSL_CTX_FUNCTION, res);
curl_easy_setopt(p.curl, CURLOPT_SSL_CTX_DATA, &p);
{
int lu; int i=0;
- while ((lu = BIO_read (in,&binaryptr[i],tabLength-i)) >0 ) {
+ while((lu = BIO_read (in, &binaryptr[i], tabLength-i)) >0 ) {
i+=lu;
- if (i== tabLength) {
+ if(i== tabLength) {
tabLength+=100;
- binaryptr=realloc(binaryptr,tabLength); /* should be more careful */
+ binaryptr=realloc(binaryptr, tabLength); /* should be more careful */
}
}
tabLength = i;
/* Now specify the POST binary data */
curl_easy_setopt(p.curl, CURLOPT_POSTFIELDS, binaryptr);
- curl_easy_setopt(p.curl, CURLOPT_POSTFIELDSIZE,(long)tabLength);
+ curl_easy_setopt(p.curl, CURLOPT_POSTFIELDSIZE, (long)tabLength);
/* Perform the request, res will get the return code */
- BIO_printf(p.errorbio,"%d %s %d\n", __LINE__, "curl_easy_perform",
+ BIO_printf(p.errorbio, "%d %s %d\n", __LINE__, "curl_easy_perform",
res = curl_easy_perform(p.curl));
{
- int result =curl_easy_getinfo(p.curl,CURLINFO_CONTENT_TYPE,&response);
- if( mimetypeaccept && p.verbose)
- if(!strcmp(mimetypeaccept,response))
- BIO_printf(p.errorbio,"the response has a correct mimetype : %s\n",
+ int result =curl_easy_getinfo(p.curl, CURLINFO_CONTENT_TYPE, &response);
+ if(mimetypeaccept && p.verbose)
+ if(!strcmp(mimetypeaccept, response))
+ BIO_printf(p.errorbio, "the response has a correct mimetype : %s\n",
response);
else
- BIO_printf(p.errorbio,"the response doesn\'t have an acceptable "
+ BIO_printf(p.errorbio, "the response doesn\'t have an acceptable "
"mime type, it is %s instead of %s\n",
- response,mimetypeaccept);
+ response, mimetypeaccept);
}
/*** code d'erreur si accept mime ***, egalement code return HTTP != 200 ***/
BIO_free(out);
return (EXIT_SUCCESS);
- err: BIO_printf(p.errorbio,"error");
+ err: BIO_printf(p.errorbio, "error");
exit(1);
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
for(c = 0; (c < width) && (i+c < size); c++) {
/* check for 0D0A; if found, skip past and start a new line of output */
- if (nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
+ if(nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
i+=(c+2-width);
break;
}
fprintf(stream, "%c",
(ptr[i+c]>=0x20) && (ptr[i+c]<0x80)?ptr[i+c]:'.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
- if (nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
+ if(nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
i+=(c+3-width);
break;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
{
DPRINT("%s %li\n", __PRETTY_FUNCTION__, timeout_ms);
ev_timer_stop(g->loop, &g->timer_event);
- if (timeout_ms > 0)
- {
+ if(timeout_ms > 0) {
double t = timeout_ms / 1000;
ev_timer_init(&g->timer_event, timer_cb, t, 0.);
ev_timer_start(g->loop, &g->timer_event);
- }else
+ }
+ else
timer_cb(g->loop, &g->timer_event, 0);
return 0;
}
/* Die if we get a bad CURLMcode somewhere */
static void mcode_or_die(const char *where, CURLMcode code)
{
- if ( CURLM_OK != code )
- {
+ if(CURLM_OK != code) {
const char *s;
- switch ( code )
- {
- case CURLM_BAD_HANDLE: s="CURLM_BAD_HANDLE"; break;
- case CURLM_BAD_EASY_HANDLE: s="CURLM_BAD_EASY_HANDLE"; break;
- case CURLM_OUT_OF_MEMORY: s="CURLM_OUT_OF_MEMORY"; break;
- case CURLM_INTERNAL_ERROR: s="CURLM_INTERNAL_ERROR"; break;
- case CURLM_UNKNOWN_OPTION: s="CURLM_UNKNOWN_OPTION"; break;
- case CURLM_LAST: s="CURLM_LAST"; break;
- default: s="CURLM_unknown";
+ switch (code) {
+ case CURLM_BAD_HANDLE:
+ s="CURLM_BAD_HANDLE";
+ break;
+ case CURLM_BAD_EASY_HANDLE:
+ s="CURLM_BAD_EASY_HANDLE";
+ break;
+ case CURLM_OUT_OF_MEMORY:
+ s="CURLM_OUT_OF_MEMORY";
+ break;
+ case CURLM_INTERNAL_ERROR:
+ s="CURLM_INTERNAL_ERROR";
+ break;
+ case CURLM_UNKNOWN_OPTION:
+ s="CURLM_UNKNOWN_OPTION";
+ break;
+ case CURLM_LAST:
+ s="CURLM_LAST";
break;
- case CURLM_BAD_SOCKET: s="CURLM_BAD_SOCKET";
+ default:
+ s="CURLM_unknown";
+ break;
+ case CURLM_BAD_SOCKET:
+ s="CURLM_BAD_SOCKET";
fprintf(MSG_OUT, "ERROR: %s returns %s\n", where, s);
/* ignore this error */
return;
CURLcode res;
fprintf(MSG_OUT, "REMAINING: %d\n", g->still_running);
- while ((msg = curl_multi_info_read(g->multi, &msgs_left))) {
- if (msg->msg == CURLMSG_DONE) {
+ while((msg = curl_multi_info_read(g->multi, &msgs_left))) {
+ if(msg->msg == CURLMSG_DONE) {
easy = msg->easy_handle;
res = msg->data.result;
curl_easy_getinfo(easy, CURLINFO_PRIVATE, &conn);
rc = curl_multi_socket_action(g->multi, w->fd, action, &g->still_running);
mcode_or_die("event_cb: curl_multi_socket_action", rc);
check_multi_info(g);
- if ( g->still_running <= 0 )
- {
+ if(g->still_running <= 0) {
fprintf(MSG_OUT, "last transfer done, kill timeout\n");
ev_timer_stop(g->loop, &g->timer_event);
}
GlobalInfo *g = (GlobalInfo *)w->data;
CURLMcode rc;
- rc = curl_multi_socket_action(g->multi, CURL_SOCKET_TIMEOUT, 0, &g->still_running);
+ rc = curl_multi_socket_action(g->multi, CURL_SOCKET_TIMEOUT, 0,
+ &g->still_running);
mcode_or_die("timer_cb: curl_multi_socket_action", rc);
check_multi_info(g);
}
static void remsock(SockInfo *f, GlobalInfo *g)
{
printf("%s \n", __PRETTY_FUNCTION__);
- if ( f )
- {
- if ( f->evset )
+ if(f) {
+ if(f->evset)
ev_io_stop(g->loop, &f->ev);
free(f);
}
f->sockfd = s;
f->action = act;
f->easy = e;
- if ( f->evset )
+ if(f->evset)
ev_io_stop(g->loop, &f->ev);
ev_io_init(&f->ev, event_cb, f->sockfd, kind);
f->ev.data = g;
fprintf(MSG_OUT,
"socket callback: s=%d e=%p what=%s ", s, e, whatstr[what]);
- if ( what == CURL_POLL_REMOVE )
- {
+ if(what == CURL_POLL_REMOVE) {
fprintf(MSG_OUT, "\n");
remsock(fdp, g);
- } else
- {
- if ( !fdp )
- {
+ }
+ else {
+ if(!fdp) {
fprintf(MSG_OUT, "Adding data: %s\n", whatstr[what]);
addsock(s, e, what, g);
- } else
- {
+ }
+ else {
fprintf(MSG_OUT,
"Changing action from %s to %s\n",
whatstr[fdp->action], whatstr[what]);
conn->error[0]='\0';
conn->easy = curl_easy_init();
- if ( !conn->easy )
- {
+ if(!conn->easy) {
fprintf(MSG_OUT, "curl_easy_init() failed, exiting!\n");
exit(2);
}
int n=0;
GlobalInfo *g = (GlobalInfo *)w->data;
- do
- {
+ do {
s[0]='\0';
rv=fscanf(g->input, "%1023s%n", s, &n);
s[n]='\0';
- if ( n && s[0] )
- {
- new_conn(s,g); /* if we read a URL, go get it! */
- } else break;
- } while ( rv != EOF );
+ if(n && s[0]) {
+ new_conn(s, g); /* if we read a URL, go get it! */
+ }
+ else
+ break;
+ } while(rv != EOF);
}
/* Create a named pipe and tell libevent to monitor it */
curl_socket_t sockfd;
fprintf(MSG_OUT, "Creating named pipe \"%s\"\n", fifo);
- if ( lstat (fifo, &st) == 0 )
- {
- if ( (st.st_mode & S_IFMT) == S_IFREG )
- {
+ if(lstat (fifo, &st) == 0) {
+ if((st.st_mode & S_IFMT) == S_IFREG) {
errno = EEXIST;
perror("lstat");
exit (1);
}
}
unlink(fifo);
- if ( mkfifo (fifo, 0600) == -1 )
- {
+ if(mkfifo (fifo, 0600) == -1) {
perror("mkfifo");
exit (1);
}
sockfd = open(fifo, O_RDWR | O_NONBLOCK, 0);
- if ( sockfd == -1 )
- {
+ if(sockfd == -1) {
perror("open");
exit (1);
}
fprintf(MSG_OUT, "Now, pipe some URL's into > %s\n", fifo);
ev_io_init(&g->fifo_event, fifo_cb, sockfd, EV_READ);
ev_io_start(g->loop, &g->fifo_event);
- return(0);
+ return (0);
}
int main(int argc, char **argv)
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
WSADATA wsaData;
int initwsa;
- if((initwsa = WSAStartup(MAKEWORD(2,0), &wsaData)) != 0) {
+ if((initwsa = WSAStartup(MAKEWORD(2, 0), &wsaData)) != 0) {
printf("WSAStartup failed: %d\n", initwsa);
return 1;
}
curl_easy_setopt(curl, CURLOPT_URL, "http://99.99.99.99:9999");
/* Create the socket "manually" */
- if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) == CURL_SOCKET_BAD ) {
+ if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == CURL_SOCKET_BAD ) {
printf("Error creating listening socket.\n");
return 3;
}
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORTNUM);
- if (INADDR_NONE == (servaddr.sin_addr.s_addr = inet_addr(IPADDR)))
+ if(INADDR_NONE == (servaddr.sin_addr.s_addr = inet_addr(IPADDR)))
return 2;
- if(connect(sockfd,(struct sockaddr *) &servaddr, sizeof(servaddr)) ==
+ if(connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) ==
-1) {
close(sockfd);
printf("client error: connect: %s\n", strerror(errno));
typedef struct fcurl_data URL_FILE;
/* exported functions */
-URL_FILE *url_fopen(const char *url,const char *operation);
+URL_FILE *url_fopen(const char *url, const char *operation);
int url_fclose(URL_FILE *file);
int url_feof(URL_FILE *file);
size_t url_fread(void *ptr, size_t size, size_t nmemb, URL_FILE *file);
if(size > rembuff) {
/* not enough space in buffer */
- newbuff=realloc(url->buffer,url->buffer_len + (size - rembuff));
+ newbuff=realloc(url->buffer, url->buffer_len + (size - rembuff));
if(newbuff==NULL) {
- fprintf(stderr,"callback buffer grow failed\n");
+ fprintf(stderr, "callback buffer grow failed\n");
size=rembuff;
}
else {
/* get file descriptors from the transfers */
mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
return 0;
}
-URL_FILE *url_fopen(const char *url,const char *operation)
+URL_FILE *url_fopen(const char *url, const char *operation)
{
/* this code could check for URLs or types in the 'url' and
basically use the real fopen() for standard files */
memset(file, 0, sizeof(URL_FILE));
- if((file->handle.file=fopen(url,operation)))
+ if((file->handle.file=fopen(url, operation)))
file->type = CFTYPE_FILE; /* marked as URL */
else {
switch(file->type) {
case CFTYPE_FILE:
- want=fread(ptr,size,nmemb,file->handle.file);
+ want=fread(ptr, size, nmemb, file->handle.file);
break;
case CFTYPE_CURL:
want = nmemb * size;
- fill_buffer(file,want);
+ fill_buffer(file, want);
/* check if theres data in the buffer - if not fill_buffer()
* either errored or EOF */
/* xfer data to caller */
memcpy(ptr, file->buffer, want);
- use_buffer(file,want);
+ use_buffer(file, want);
want = want / size; /* number of items */
break;
break;
case CFTYPE_CURL:
- fill_buffer(file,want);
+ fill_buffer(file, want);
/* check if theres data in the buffer - if not fill either errored or
* EOF */
memcpy(ptr, file->buffer, want);
ptr[want]=0;/* allways null terminate */
- use_buffer(file,want);
+ use_buffer(file, want);
break;
}
}
+#define FGETSFILE "fgets.test"
+#define FREADFILE "fread.test"
+#define REWINDFILE "rewind.test"
+
/* Small main program to retrive from a url using fgets and fread saving the
* output to two test files (note the fgets method will corrupt binary files if
* they contain 0 chars */
url=argv[1];/* use passed url */
/* copy from url line by line with fgets */
- outf=fopen("fgets.test","w+");
+ outf=fopen(FGETSFILE, "wb+");
if(!outf) {
perror("couldn't open fgets output file\n");
return 1;
}
while(!url_feof(handle)) {
- url_fgets(buffer,sizeof(buffer),handle);
- fwrite(buffer,1,strlen(buffer),outf);
+ url_fgets(buffer, sizeof(buffer), handle);
+ fwrite(buffer, 1, strlen(buffer), outf);
}
url_fclose(handle);
/* Copy from url with fread */
- outf=fopen("fread.test","w+");
+ outf=fopen(FREADFILE, "wb+");
if(!outf) {
perror("couldn't open fread output file\n");
return 1;
do {
nread = url_fread(buffer, 1, sizeof(buffer), handle);
- fwrite(buffer,1,nread,outf);
+ fwrite(buffer, 1, nread, outf);
} while(nread);
url_fclose(handle);
/* Test rewind */
- outf=fopen("rewind.test","w+");
+ outf=fopen(REWINDFILE, "wb+");
if(!outf) {
perror("couldn't open fread output file\n");
return 1;
return 2;
}
- nread = url_fread(buffer, 1,sizeof(buffer), handle);
- fwrite(buffer,1,nread,outf);
+ nread = url_fread(buffer, 1, sizeof(buffer), handle);
+ fwrite(buffer, 1, nread, outf);
url_rewind(handle);
buffer[0]='\n';
- fwrite(buffer,1,1,outf);
-
- nread = url_fread(buffer, 1,sizeof(buffer), handle);
- fwrite(buffer,1,nread,outf);
+ fwrite(buffer, 1, 1, outf);
+ nread = url_fread(buffer, 1, sizeof(buffer), handle);
+ fwrite(buffer, 1, nread, outf);
url_fclose(handle);
fclose(outf);
-
return 0;/* all done */
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
return CURL_CHUNK_BGN_FUNC_SKIP;
}
- data->output = fopen(finfo->filename, "w");
+ data->output = fopen(finfo->filename, "wb");
if(!data->output) {
return CURL_CHUNK_BGN_FUNC_FAIL;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* You better replace the URL with one that works!
*/
curl_easy_setopt(curl, CURLOPT_URL,
- "ftp://ftp.example.com/pub/www/utilities/curl/curl-7.9.2.tar.gz");
+ "ftp://ftp.example.com/curl/curl-7.9.2.tar.gz");
/* Define our callback to get called when there's data to be written */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_fwrite);
/* Set a pointer to our struct to pass to the callback */
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
time_t file_time = (time_t)filetime;
printf("filetime %s: %s", filename, ctime(&file_time));
}
- res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &filesize);
+ res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD,
+ &filesize);
if((CURLE_OK == res) && (filesize>0.0))
printf("filesize %s: %0.0f bytes\n", filename, filesize);
- } else {
+ }
+ else {
/* we failed */
fprintf(stderr, "curl told us %d\n", res);
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
return fwrite(ptr, size, nmemb, writehere);
}
+#define FTPBODY "ftp-list"
+#define FTPHEADERS "ftp-responses"
+
int main(void)
{
CURL *curl;
FILE *respfile;
/* local file name to store the file as */
- ftpfile = fopen("ftp-list", "wb"); /* b is binary, needed on win32 */
+ ftpfile = fopen(FTPBODY, "wb"); /* b is binary, needed on win32 */
/* local file name to store the FTP server's response lines in */
- respfile = fopen("ftp-responses", "wb"); /* b is binary, needed on win32 */
+ respfile = fopen(FTPHEADERS, "wb"); /* b is binary, needed on win32 */
curl = curl_easy_init();
if(curl) {
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
/* specify target */
- curl_easy_setopt(curl,CURLOPT_URL, REMOTE_URL);
+ 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);
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
/* The MinGW headers are missing a few Win32 function definitions,
you shouldn't need this if you use VC++ */
#if defined(__MINGW32__) && !defined(__MINGW64__)
-int __cdecl _snscanf(const char * input, size_t length, const char * format, ...);
+int __cdecl _snscanf(const char * input, size_t length,
+ const char * format, ...);
#endif
/* _snscanf() is Win32 specific */
r = _snscanf(ptr, size * nmemb, "Content-Length: %ld\n", &len);
- if (r) /* Microsoft: we don't read the specs */
+ if(r) /* Microsoft: we don't read the specs */
*((long *) stream) = len;
return size * nmemb;
FILE *f = stream;
size_t n;
- if (ferror(f))
+ if(ferror(f))
return CURL_READFUNC_ABORT;
n = fread(ptr, size, nmemb, f) * size;
int c;
f = fopen(localpath, "rb");
- if (f == NULL) {
+ if(!f) {
perror(NULL);
return 0;
}
curl_easy_setopt(curlhandle, CURLOPT_URL, remotepath);
- if (timeout)
+ if(timeout)
curl_easy_setopt(curlhandle, CURLOPT_FTP_RESPONSE_TIMEOUT, timeout);
curl_easy_setopt(curlhandle, CURLOPT_HEADERFUNCTION, getcontentlengthfunc);
curl_easy_setopt(curlhandle, CURLOPT_READFUNCTION, readfunc);
curl_easy_setopt(curlhandle, CURLOPT_READDATA, f);
- curl_easy_setopt(curlhandle, CURLOPT_FTPPORT, "-"); /* disable passive mode */
+ /* disable passive mode */
+ curl_easy_setopt(curlhandle, CURLOPT_FTPPORT, "-");
curl_easy_setopt(curlhandle, CURLOPT_FTP_CREATE_MISSING_DIRS, 1L);
curl_easy_setopt(curlhandle, CURLOPT_VERBOSE, 1L);
- for (c = 0; (r != CURLE_OK) && (c < tries); c++) {
+ for(c = 0; (r != CURLE_OK) && (c < tries); c++) {
/* are we resuming? */
- if (c) { /* yes */
+ if(c) { /* yes */
/* determine the length of the file already written */
/*
curl_easy_setopt(curlhandle, CURLOPT_HEADER, 1L);
r = curl_easy_perform(curlhandle);
- if (r != CURLE_OK)
+ if(r != CURLE_OK)
continue;
curl_easy_setopt(curlhandle, CURLOPT_NOBODY, 0L);
fclose(f);
- if (r == CURLE_OK)
+ if(r == CURLE_OK)
return 1;
else {
fprintf(stderr, "%s\n", curl_easy_strerror(r));
curl_global_init(CURL_GLOBAL_ALL);
curlhandle = curl_easy_init();
- upload(curlhandle, "ftp://user:pass@example.com/path/file", "C:\\file", 0, 3);
+ upload(curlhandle, "ftp://user:pass@example.com/path/file", "C:\\file",
+ 0, 3);
curl_easy_cleanup(curlhandle);
curl_global_cleanup();
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
*
* Written by Jeff Pohlmeyer
-Requires glib-2.x and a (POSIX?) system that has mkfifo().
+ Requires glib-2.x and a (POSIX?) system that has mkfifo().
-This is an adaptation of libcurl's "hipev.c" and libevent's "event-test.c"
-sample programs, adapted to use glib's g_io_channel in place of libevent.
+ This is an adaptation of libcurl's "hipev.c" and libevent's "event-test.c"
+ sample programs, adapted to use glib's g_io_channel in place of libevent.
-When running, the program creates the named pipe "hiper.fifo"
+ When running, the program creates the named pipe "hiper.fifo"
-Whenever there is input into the fifo, the program reads the input as a list
-of URL's and creates some new easy handles to fetch each URL via the
-curl_multi "hiper" API.
+ Whenever there is input into the fifo, the program reads the input as a list
+ of URL's and creates some new easy handles to fetch each URL via the
+ curl_multi "hiper" API.
-Thus, you can try a single URL:
- % echo http://www.yahoo.com > hiper.fifo
+ Thus, you can try a single URL:
+ % echo http://www.yahoo.com > hiper.fifo
-Or a whole bunch of them:
- % cat my-url-list > hiper.fifo
+ Or a whole bunch of them:
+ % cat my-url-list > hiper.fifo
-The fifo buffer is handled almost instantly, so you can even add more URL's
-while the previous requests are still being downloaded.
+ The fifo buffer is handled almost instantly, so you can even add more URL's
+ while the previous requests are still being downloaded.
-This is purely a demo app, all retrieved data is simply discarded by the write
-callback.
+ This is purely a demo app, all retrieved data is simply discarded by the write
+ callback.
*/
-
#include <glib.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <curl/curl.h>
-
#define MSG_OUT g_print /* Change to "g_error" to write to stderr */
#define SHOW_VERBOSE 0 /* Set to non-zero for libcurl messages */
#define SHOW_PROGRESS 0 /* Set to non-zero to enable progress callback */
-
-
/* Global information, common to all connections */
typedef struct _GlobalInfo {
CURLM *multi;
int still_running;
} GlobalInfo;
-
-
/* Information associated with a specific easy handle */
typedef struct _ConnInfo {
CURL *easy;
char error[CURL_ERROR_SIZE];
} ConnInfo;
-
/* Information associated with a specific socket */
typedef struct _SockInfo {
curl_socket_t sockfd;
GlobalInfo *global;
} SockInfo;
-
-
-
/* Die if we get a bad CURLMcode somewhere */
static void mcode_or_die(const char *where, CURLMcode code) {
- if ( CURLM_OK != code ) {
+ if(CURLM_OK != code) {
const char *s;
switch (code) {
- case CURLM_BAD_HANDLE: s="CURLM_BAD_HANDLE"; break;
- case CURLM_BAD_EASY_HANDLE: s="CURLM_BAD_EASY_HANDLE"; break;
- case CURLM_OUT_OF_MEMORY: s="CURLM_OUT_OF_MEMORY"; break;
- case CURLM_INTERNAL_ERROR: s="CURLM_INTERNAL_ERROR"; break;
- case CURLM_BAD_SOCKET: s="CURLM_BAD_SOCKET"; break;
- case CURLM_UNKNOWN_OPTION: s="CURLM_UNKNOWN_OPTION"; break;
- case CURLM_LAST: s="CURLM_LAST"; break;
- default: s="CURLM_unknown";
+ case CURLM_BAD_HANDLE: s="CURLM_BAD_HANDLE"; break;
+ case CURLM_BAD_EASY_HANDLE: s="CURLM_BAD_EASY_HANDLE"; break;
+ case CURLM_OUT_OF_MEMORY: s="CURLM_OUT_OF_MEMORY"; break;
+ case CURLM_INTERNAL_ERROR: s="CURLM_INTERNAL_ERROR"; break;
+ case CURLM_BAD_SOCKET: s="CURLM_BAD_SOCKET"; break;
+ case CURLM_UNKNOWN_OPTION: s="CURLM_UNKNOWN_OPTION"; break;
+ case CURLM_LAST: s="CURLM_LAST"; break;
+ default: s="CURLM_unknown";
}
MSG_OUT("ERROR: %s returns %s\n", where, s);
exit(code);
}
}
-
-
/* Check for completed transfers, and remove their easy handles */
static void check_multi_info(GlobalInfo *g)
{
CURLcode res;
MSG_OUT("REMAINING: %d\n", g->still_running);
- while ((msg = curl_multi_info_read(g->multi, &msgs_left))) {
- if (msg->msg == CURLMSG_DONE) {
+ while((msg = curl_multi_info_read(g->multi, &msgs_left))) {
+ if(msg->msg == CURLMSG_DONE) {
easy = msg->easy_handle;
res = msg->data.result;
curl_easy_getinfo(easy, CURLINFO_PRIVATE, &conn);
}
}
-
-
/* Called by glib when our timeout expires */
static gboolean timer_cb(gpointer data)
{
CURLMcode rc;
rc = curl_multi_socket_action(g->multi,
- CURL_SOCKET_TIMEOUT, 0, &g->still_running);
+ CURL_SOCKET_TIMEOUT, 0, &g->still_running);
mcode_or_die("timer_cb: curl_multi_socket_action", rc);
check_multi_info(g);
return FALSE;
}
-
-
/* Update the event timer after curl_multi library calls */
static int update_timeout_cb(CURLM *multi, long timeout_ms, void *userp)
{
timeout.tv_usec = (timeout_ms%1000)*1000;
MSG_OUT("*** update_timeout_cb %ld => %ld:%ld ***\n",
- timeout_ms, timeout.tv_sec, timeout.tv_usec);
+ timeout_ms, timeout.tv_sec, timeout.tv_usec);
g->timer_event = g_timeout_add(timeout_ms, timer_cb, g);
return 0;
}
-
-
-
/* Called by glib when we get action on a multi socket */
static gboolean event_cb(GIOChannel *ch, GIOCondition condition, gpointer data)
{
check_multi_info(g);
if(g->still_running) {
return TRUE;
- } else {
+ }
+ else {
MSG_OUT("last transfer done, kill timeout\n");
- if (g->timer_event) { g_source_remove(g->timer_event); }
+ if(g->timer_event) {
+ g_source_remove(g->timer_event);
+ }
return FALSE;
}
}
-
-
/* Clean up the SockInfo structure */
static void remsock(SockInfo *f)
{
- if (!f) { return; }
- if (f->ev) { g_source_remove(f->ev); }
+ if(!f) {
+ return;
+ }
+ if(f->ev) {
+ g_source_remove(f->ev);
+ }
g_free(f);
}
-
-
/* Assign information to a SockInfo structure */
static void setsock(SockInfo*f, curl_socket_t s, CURL*e, int act, GlobalInfo*g)
{
GIOCondition kind =
- (act&CURL_POLL_IN?G_IO_IN:0)|(act&CURL_POLL_OUT?G_IO_OUT:0);
+ (act&CURL_POLL_IN?G_IO_IN:0)|(act&CURL_POLL_OUT?G_IO_OUT:0);
f->sockfd = s;
f->action = act;
f->easy = e;
- if (f->ev) { g_source_remove(f->ev); }
- f->ev=g_io_add_watch(f->ch, kind, event_cb,g);
-
+ if(f->ev) {
+ g_source_remove(f->ev);
+ }
+ f->ev=g_io_add_watch(f->ch, kind, event_cb, g);
}
-
-
/* Initialize a new SockInfo structure */
static void addsock(curl_socket_t s, CURL *easy, int action, GlobalInfo *g)
{
curl_multi_assign(g->multi, s, fdp);
}
-
-
/* CURLMOPT_SOCKETFUNCTION */
static int sock_cb(CURL *e, curl_socket_t s, int what, void *cbp, void *sockp)
{
static const char *whatstr[]={ "none", "IN", "OUT", "INOUT", "REMOVE" };
MSG_OUT("socket callback: s=%d e=%p what=%s ", s, e, whatstr[what]);
- if (what == CURL_POLL_REMOVE) {
+ if(what == CURL_POLL_REMOVE) {
MSG_OUT("\n");
remsock(fdp);
- } else {
- if (!fdp) {
+ }
+ else {
+ if(!fdp) {
MSG_OUT("Adding data: %s%s\n",
- what&CURL_POLL_IN?"READ":"",
- what&CURL_POLL_OUT?"WRITE":"" );
+ what&CURL_POLL_IN?"READ":"",
+ what&CURL_POLL_OUT?"WRITE":"" );
addsock(s, e, what, g);
}
else {
return 0;
}
-
-
/* CURLOPT_WRITEFUNCTION */
static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *data)
{
return realsize;
}
-
-
/* CURLOPT_PROGRESSFUNCTION */
-static int prog_cb (void *p, double dltotal, double dlnow, double ult, double uln)
+static int prog_cb (void *p, double dltotal, double dlnow, double ult,
+ double uln)
{
ConnInfo *conn = (ConnInfo *)p;
MSG_OUT("Progress: %s (%g/%g)\n", conn->url, dlnow, dltotal);
return 0;
}
-
-
/* Create a new easy handle, and add it to the global curl_multi */
static void new_conn(char *url, GlobalInfo *g )
{
CURLMcode rc;
conn = g_malloc0(sizeof(ConnInfo));
-
conn->error[0]='\0';
-
conn->easy = curl_easy_init();
- if (!conn->easy) {
+ if(!conn->easy) {
MSG_OUT("curl_easy_init() failed, exiting!\n");
exit(2);
}
that the necessary socket_action() call will be called by this app */
}
-
/* This gets called by glib whenever data is received from the fifo */
static gboolean fifo_cb (GIOChannel *ch, GIOCondition condition, gpointer data)
{
- #define BUF_SIZE 1024
+#define BUF_SIZE 1024
gsize len, tp;
gchar *buf, *tmp, *all=NULL;
GIOStatus rv;
do {
GError *err=NULL;
- rv = g_io_channel_read_line (ch,&buf,&len,&tp,&err);
- if ( buf ) {
- if (tp) { buf[tp]='\0'; }
- new_conn(buf,(GlobalInfo*)data);
+ rv = g_io_channel_read_line(ch, &buf, &len, &tp, &err);
+ if(buf) {
+ if(tp) {
+ buf[tp]='\0';
+ }
+ new_conn(buf, (GlobalInfo*)data);
g_free(buf);
- } else {
+ }
+ else {
buf = g_malloc(BUF_SIZE+1);
- while (TRUE) {
+ while(TRUE) {
buf[BUF_SIZE]='\0';
- g_io_channel_read_chars(ch,buf,BUF_SIZE,&len,&err);
- if (len) {
+ g_io_channel_read_chars(ch, buf, BUF_SIZE, &len, &err);
+ if(len) {
buf[len]='\0';
- if (all) {
+ if(all) {
tmp=all;
all=g_strdup_printf("%s%s", tmp, buf);
g_free(tmp);
- } else {
+ }
+ else {
all = g_strdup(buf);
}
- } else {
- break;
+ }
+ else {
+ break;
}
}
- if (all) {
- new_conn(all,(GlobalInfo*)data);
+ if(all) {
+ new_conn(all, (GlobalInfo*)data);
g_free(all);
}
g_free(buf);
}
- if ( err ) {
+ if(err) {
g_error("fifo_cb: %s", err->message);
g_free(err);
break;
}
- } while ( (len) && (rv == G_IO_STATUS_NORMAL) );
+ } while((len) && (rv == G_IO_STATUS_NORMAL));
return TRUE;
}
-
-
-
int init_fifo(void)
{
- struct stat st;
- const char *fifo = "hiper.fifo";
- int socket;
-
- if (lstat (fifo, &st) == 0) {
- if ((st.st_mode & S_IFMT) == S_IFREG) {
- errno = EEXIST;
- perror("lstat");
- exit (1);
+ struct stat st;
+ const char *fifo = "hiper.fifo";
+ int socket;
+
+ if(lstat (fifo, &st) == 0) {
+ if((st.st_mode & S_IFMT) == S_IFREG) {
+ errno = EEXIST;
+ perror("lstat");
+ exit (1);
+ }
}
- }
-
- unlink (fifo);
- if (mkfifo (fifo, 0600) == -1) {
- perror("mkfifo");
- exit (1);
- }
- socket = open (fifo, O_RDWR | O_NONBLOCK, 0);
+ unlink (fifo);
+ if(mkfifo (fifo, 0600) == -1) {
+ perror("mkfifo");
+ exit (1);
+ }
- if (socket == -1) {
- perror("open");
- exit (1);
- }
- MSG_OUT("Now, pipe some URL's into > %s\n", fifo);
+ socket = open (fifo, O_RDWR | O_NONBLOCK, 0);
- return socket;
+ if(socket == -1) {
+ perror("open");
+ exit (1);
+ }
+ MSG_OUT("Now, pipe some URL's into > %s\n", fifo);
+ return socket;
}
-
-
-
int main(int argc, char **argv)
{
GlobalInfo *g;
fd=init_fifo();
ch=g_io_channel_unix_new(fd);
- g_io_add_watch(ch,G_IO_IN,fifo_cb,g);
- gmain=g_main_loop_new(NULL,FALSE);
+ g_io_add_watch(ch, G_IO_IN, fifo_cb, g);
+ gmain=g_main_loop_new(NULL, FALSE);
g->multi = curl_multi_init();
curl_multi_setopt(g->multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g->multi, CURLMOPT_SOCKETDATA, g);
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
/* Die if we get a bad CURLMcode somewhere */
static void mcode_or_die(const char *where, CURLMcode code)
{
- if ( CURLM_OK != code ) {
+ if(CURLM_OK != code) {
const char *s;
switch (code) {
case CURLM_BAD_HANDLE: s="CURLM_BAD_HANDLE"; break;
CURLcode res;
fprintf(MSG_OUT, "REMAINING: %d\n", g->still_running);
- while ((msg = curl_multi_info_read(g->multi, &msgs_left))) {
- if (msg->msg == CURLMSG_DONE) {
+ while((msg = curl_multi_info_read(g->multi, &msgs_left))) {
+ if(msg->msg == CURLMSG_DONE) {
easy = msg->easy_handle;
res = msg->data.result;
curl_easy_getinfo(easy, CURLINFO_PRIVATE, &conn);
mcode_or_die("event_cb: curl_multi_socket_action", rc);
check_multi_info(g);
- if ( g->still_running <= 0 ) {
+ if(g->still_running <= 0 ) {
fprintf(MSG_OUT, "last transfer done, kill timeout\n");
- if (evtimer_pending(g->timer_event, NULL)) {
+ if(evtimer_pending(g->timer_event, NULL)) {
evtimer_del(g->timer_event);
}
}
/* Clean up the SockInfo structure */
static void remsock(SockInfo *f)
{
- if (f) {
- if (f->evset)
+ if(f) {
+ if(f->evset)
event_free(f->ev);
free(f);
}
f->sockfd = s;
f->action = act;
f->easy = e;
- if (f->evset)
+ if(f->evset)
event_free(f->ev);
f->ev = event_new(g->evbase, f->sockfd, kind, event_cb, g);
f->evset = 1;
fprintf(MSG_OUT,
"socket callback: s=%d e=%p what=%s ", s, e, whatstr[what]);
- if (what == CURL_POLL_REMOVE) {
+ if(what == CURL_POLL_REMOVE) {
fprintf(MSG_OUT, "\n");
remsock(fdp);
}
else {
- if (!fdp) {
+ if(!fdp) {
fprintf(MSG_OUT, "Adding data: %s\n", whatstr[what]);
addsock(s, e, what, g);
}
conn->error[0]='\0';
conn->easy = curl_easy_init();
- if (!conn->easy) {
+ if(!conn->easy) {
fprintf(MSG_OUT, "curl_easy_init() failed, exiting!\n");
exit(2);
}
s[0]='\0';
rv=fscanf(g->input, "%1023s%n", s, &n);
s[n]='\0';
- if ( n && s[0] ) {
- new_conn(s,arg); /* if we read a URL, go get it! */
- } else break;
- } while ( rv != EOF);
+ if(n && s[0] ) {
+ new_conn(s, arg); /* if we read a URL, go get it! */
+ }
+ else
+ break;
+ } while(rv != EOF);
}
/* Create a named pipe and tell libevent to monitor it */
curl_socket_t sockfd;
fprintf(MSG_OUT, "Creating named pipe \"%s\"\n", fifo);
- if (lstat (fifo, &st) == 0) {
- if ((st.st_mode & S_IFMT) == S_IFREG) {
+ if(lstat (fifo, &st) == 0) {
+ if((st.st_mode & S_IFMT) == S_IFREG) {
errno = EEXIST;
perror("lstat");
exit (1);
}
}
unlink(fifo);
- if (mkfifo (fifo, 0600) == -1) {
+ if(mkfifo (fifo, 0600) == -1) {
perror("mkfifo");
exit (1);
}
sockfd = open(fifo, O_RDWR | O_NONBLOCK, 0);
- if (sockfd == -1) {
+ if(sockfd == -1) {
perror("open");
exit (1);
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 2012 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 2012 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
void *hsp)
{
size_t realsize = size * nmemb, p;
- for (p = 0; p < realsize; p++) {
+ for(p = 0; p < realsize; p++) {
html_parser_char_parse(hsp, ((char *)buffer)[p]);
- if (html_parser_cmp_tag(hsp, "a", 1))
- if (html_parser_cmp_attr(hsp, "href", 4))
- if (html_parser_is_in(hsp, HTML_VALUE_ENDED)) {
+ if(html_parser_cmp_tag(hsp, "a", 1))
+ if(html_parser_cmp_attr(hsp, "href", 4))
+ if(html_parser_is_in(hsp, HTML_VALUE_ENDED)) {
html_parser_val(hsp)[html_parser_val_length(hsp)] = '\0';
printf("%s\n", html_parser_val(hsp));
}
CURL *curl;
HTMLSTREAMPARSER *hsp;
- if (argc != 2) {
+ if(argc != 2) {
printf("Usage: %s URL\n", argv[0]);
return EXIT_FAILURE;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
uint r;
r = size * nmemb;
tidyBufAppend( out, in, r );
- return(r);
+ return r;
}
/* Traverse the document tree */
void dumpNode(TidyDoc doc, TidyNode tnod, int indent )
{
TidyNode child;
- for ( child = tidyGetChild(tnod); child; child = tidyGetNext(child) )
- {
+ for(child = tidyGetChild(tnod); child; child = tidyGetNext(child) ) {
ctmbstr name = tidyNodeGetName( child );
- if ( name )
- {
+ if(name) {
/* if it has a name, then it's an HTML tag ... */
TidyAttr attr;
printf( "%*.*s%s ", indent, indent, "<", name);
/* walk the attribute list */
- for ( attr=tidyAttrFirst(child); attr; attr=tidyAttrNext(attr) ) {
+ for(attr=tidyAttrFirst(child); attr; attr=tidyAttrNext(attr) ) {
printf(tidyAttrName(attr));
tidyAttrValue(attr)?printf("=\"%s\" ",
tidyAttrValue(attr)):printf(" ");
TidyBuffer docbuf = {0};
TidyBuffer tidy_errbuf = {0};
int err;
- if ( argc == 2) {
+ if(argc == 2) {
curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, argv[1]);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_errbuf);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &docbuf);
err=curl_easy_perform(curl);
- if ( !err ) {
+ if(!err) {
err = tidyParseBuffer(tdoc, &docbuf); /* parse the input */
- if ( err >= 0 ) {
+ if(err >= 0) {
err = tidyCleanAndRepair(tdoc); /* fix any problems */
- if ( err >= 0 ) {
+ if(err >= 0) {
err = tidyRunDiagnostics(tdoc); /* load tidy error buffer */
- if ( err >= 0 ) {
+ if(err >= 0) {
dumpNode( tdoc, tidyGetRoot(tdoc), 0 ); /* walk the tree */
fprintf(stderr, "%s\n", tidy_errbuf.bp); /* show errors */
}
tidyBufFree(&docbuf);
tidyBufFree(&tidy_errbuf);
tidyRelease(tdoc);
- return(err);
+ return err;
}
else
printf( "usage: %s <url>\n", argv[0] );
- return(0);
+ return 0;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
for(c = 0; (c < width) && (i+c < size); c++) {
/* check for 0D0A; if found, skip past and start a new line of output */
- if (nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
+ if(nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
i+=(c+2-width);
break;
}
fprintf(stderr, "%c",
(ptr[i+c]>=0x20) && (ptr[i+c]<0x80)?ptr[i+c]:'.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
- if (nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
+ if(nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
i+=(c+3-width);
break;
}
FILE *out;
char filename[128];
- sprintf(filename, "dl-%d", num);
+ snprintf(filename, 128, "dl-%d", num);
out = fopen(filename, "wb");
/* get file descriptors from the transfers */
mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
for(c = 0; (c < width) && (i+c < size); c++) {
/* check for 0D0A; if found, skip past and start a new line of output */
- if (nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
+ if(nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
i+=(c+2-width);
break;
}
fprintf(stderr, "%c",
(ptr[i+c]>=0x20) && (ptr[i+c]<0x80)?ptr[i+c]:'.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
- if (nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
+ if(nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
i+=(c+3-width);
break;
}
return 0;
}
+#define OUTPUTFILE "dl"
+
static void setup(CURL *hnd)
{
- FILE *out = fopen("dl", "wb");
+ FILE *out = fopen(OUTPUTFILE, "wb");
/* write to this file */
curl_easy_setopt(hnd, CURLOPT_WRITEDATA, out);
(void)parent; /* we have no use for this */
- sprintf(filename, "push%u", count++);
+ snprintf(filename, 128, "push%u", count++);
/* here's a new stream, save it in a new file for each new push */
out = fopen(filename, "wb");
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
for(c = 0; (c < width) && (i+c < size); c++) {
/* check for 0D0A; if found, skip past and start a new line of output */
- if (nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
+ if(nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
i+=(c+2-width);
break;
}
fprintf(stderr, "%c",
(ptr[i+c]>=0x20) && (ptr[i+c]<0x80)?ptr[i+c]:'.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
- if (nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
+ if(nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
i+=(c+3-width);
break;
}
struct stat file_info;
curl_off_t uploadsize;
- sprintf(filename, "dl-%d", num);
+ snprintf(filename, 128, "dl-%d", num);
out = fopen(filename, "wb");
- sprintf(url, "https://localhost:8443/upload-%d", num);
+ snprintf(url, 256, "https://localhost:8443/upload-%d", num);
/* get the file size of the local file */
stat(upload, &file_info);
/* get file descriptors from the transfers */
mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
{
CURL *curl;
CURLcode res;
- FILE * hd_src ;
+ FILE * hd_src;
struct stat file_info;
char *file;
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
"To: " TO "\r\n",
"From: " FROM "(Example User)\r\n",
"Cc: " CC "(Another example User)\r\n",
- "Message-ID: <dcd7cb36-11db-487a-9f3a-e652a9458efd@rfcpedant.example.org>\r\n",
+ "Message-ID: "
+ "<dcd7cb36-11db-487a-9f3a-e652a9458efd@rfcpedant.example.org>\r\n",
"Subject: IMAP example message\r\n",
"\r\n", /* empty line to divide headers from body, see RFC5322 */
"The body of the message starts here.\r\n",
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
curl_easy_setopt(curl, CURLOPT_PASSWORD, "secret");
/* This will fetch message 1 from the user's inbox */
- curl_easy_setopt(curl, CURLOPT_URL, "imap://imap.example.com/INBOX/;UID=1");
+ curl_easy_setopt(curl, CURLOPT_URL,
+ "imap://imap.example.com/INBOX/;UID=1");
/* Perform the fetch */
res = curl_easy_perform(curl);
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
/* get file descriptors from the transfers */
mc = curl_multi_fdset(mcurl, &fdread, &fdwrite, &fdexcep, &maxfd);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
/* This will fetch message 1 from the user's inbox. Note the use of
* imaps:// rather than imap:// to request a SSL based connection. */
- curl_easy_setopt(curl, CURLOPT_URL, "imaps://imap.example.com/INBOX/;UID=1");
+ curl_easy_setopt(curl, CURLOPT_URL,
+ "imaps://imap.example.com/INBOX/;UID=1");
/* If you want to connect to a site who isn't using a certificate that is
* signed by one of the certs in the CA bundle you have, you can skip the
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
curl_easy_setopt(curl, CURLOPT_PASSWORD, "secret");
/* This will fetch message 1 from the user's inbox */
- curl_easy_setopt(curl, CURLOPT_URL, "imap://imap.example.com/INBOX/;UID=1");
+ curl_easy_setopt(curl, CURLOPT_URL,
+ "imap://imap.example.com/INBOX/;UID=1");
/* In this example, we'll start with a plain text connection, and upgrade
* to Transport Layer Security (TLS) using the STARTTLS command. Be careful
* CURLOPT_SSL_VERIFYPEER and CURLOPT_SSL_VERIFYHOST options to 0 (false).
* curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
* curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
+ *
* That is, in general, a bad idea. It is still better than sending your
- * authentication details in plain text though.
- * Instead, you should get the issuer certificate (or the host certificate
- * if the certificate is self-signed) and add it to the set of certificates
- * that are known to libcurl using CURLOPT_CAINFO and/or CURLOPT_CAPATH. See
- * docs/SSLCERTS for more information. */
+ * authentication details in plain text though. Instead, you should get
+ * the issuer certificate (or the host certificate if the certificate is
+ * self-signed) and add it to the set of certificates that are known to
+ * libcurl using CURLOPT_CAINFO and/or CURLOPT_CAPATH. See docs/SSLCERTS
+ * for more information. */
curl_easy_setopt(curl, CURLOPT_CAINFO, "/path/to/certificate.pem");
/* Since the traffic will be encrypted, it is very useful to turn on debug
int msgs_left; /* how many messages are left */
/* Allocate one CURL handle per transfer */
- for (i=0; i<HANDLECOUNT; i++)
- handles[i] = curl_easy_init();
+ for(i=0; i<HANDLECOUNT; i++)
+ handles[i] = curl_easy_init();
/* set the options (I left out a few, you'll get the point anyway) */
curl_easy_setopt(handles[HTTP_HANDLE], CURLOPT_URL, "http://example.com");
multi_handle = curl_multi_init();
/* add the individual transfers */
- for (i=0; i<HANDLECOUNT; i++)
- curl_multi_add_handle(multi_handle, handles[i]);
+ for(i=0; i<HANDLECOUNT; i++)
+ curl_multi_add_handle(multi_handle, handles[i]);
/* we start some action by calling perform right away */
curl_multi_perform(multi_handle, &still_running);
/* get file descriptors from the transfers */
mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
} while(still_running);
/* See how the transfers went */
- while ((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
- if (msg->msg == CURLMSG_DONE) {
+ while((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
+ if(msg->msg == CURLMSG_DONE) {
int idx, found = 0;
/* Find out which handle this message is about */
- for (idx=0; idx<HANDLECOUNT; idx++) {
+ for(idx=0; idx<HANDLECOUNT; idx++) {
found = (msg->easy_handle == handles[idx]);
if(found)
break;
curl_multi_cleanup(multi_handle);
/* Free the CURL handles */
- for (i=0; i<HANDLECOUNT; i++)
- curl_easy_cleanup(handles[i]);
+ for(i=0; i<HANDLECOUNT; i++)
+ curl_easy_cleanup(handles[i]);
return 0;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
for(c = 0; (c < width) && (i+c < size); c++) {
/* check for 0D0A; if found, skip past and start a new line of output */
- if (nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
+ if(nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
i+=(c+2-width);
break;
}
fprintf(stream, "%c",
(ptr[i+c]>=0x20) && (ptr[i+c]<0x80)?ptr[i+c]:'.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
- if (nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
+ if(nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
i+=(c+3-width);
break;
}
/* get file descriptors from the transfers */
mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
/* get file descriptors from the transfers */
mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
/* get file descriptors from the transfers */
mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
/* wait for activity, timeout or "nothing" */
mc = curl_multi_wait(multi_handle, NULL, 0, 1000, &numfds);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_wait() failed, code %d.\n", mc);
break;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
FILE *file;
CURL *handle;
- sprintf(filename, "%d.download", num);
+ snprintf(filename, 50, "%d.download", num);
- file = fopen(filename, "w");
+ file = fopen(filename, "wb");
if(!file) {
fprintf(stderr, "Error opening %s\n", filename);
return;
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
#define THREAD_ID pthread_self( )
-void handle_error(const char *file, int lineno, const char *msg){
- fprintf(stderr, "** %s:%d %s\n", file, lineno, msg);
- ERR_print_errors_fp(stderr);
- /* exit(-1); */
- }
+void handle_error(const char *file, int lineno, const char *msg)
+{
+ fprintf(stderr, "** %s:%d %s\n", file, lineno, msg);
+ ERR_print_errors_fp(stderr);
+ /* exit(-1); */
+}
/* This array will store all of the mutexes available to OpenSSL. */
static MUTEX_TYPE *mutex_buf= NULL;
-
static void locking_function(int mode, int n, const char * file, int line)
{
- if (mode & CRYPTO_LOCK)
+ if(mode & CRYPTO_LOCK)
MUTEX_LOCK(mutex_buf[n]);
else
MUTEX_UNLOCK(mutex_buf[n]);
int i;
mutex_buf = malloc(CRYPTO_num_locks( ) * sizeof(MUTEX_TYPE));
- if (!mutex_buf)
+ if(!mutex_buf)
return 0;
- for (i = 0; i < CRYPTO_num_locks( ); i++)
+ for(i = 0; i < CRYPTO_num_locks( ); i++)
MUTEX_SETUP(mutex_buf[i]);
CRYPTO_set_id_callback(id_function);
CRYPTO_set_locking_callback(locking_function);
{
int i;
- if (!mutex_buf)
+ if(!mutex_buf)
return 0;
CRYPTO_set_id_callback(NULL);
CRYPTO_set_locking_callback(NULL);
- for (i = 0; i < CRYPTO_num_locks( ); i++)
+ for(i = 0; i < CRYPTO_num_locks( ); i++)
MUTEX_CLEANUP(mutex_buf[i]);
free(mutex_buf);
mutex_buf = NULL;
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
/* get file descriptors from the transfers */
mc = curl_multi_fdset(mcurl, &fdread, &fdwrite, &fdexcep, &maxfd);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* CURLOPT_SSL_VERIFYPEER and CURLOPT_SSL_VERIFYHOST options to 0 (false).
* curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
* curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
+ *
* That is, in general, a bad idea. It is still better than sending your
- * authentication details in plain text though.
- * Instead, you should get the issuer certificate (or the host certificate
- * if the certificate is self-signed) and add it to the set of certificates
- * that are known to libcurl using CURLOPT_CAINFO and/or CURLOPT_CAPATH. See
- * docs/SSLCERTS for more information. */
+ * authentication details in plain text though. Instead, you should get
+ * the issuer certificate (or the host certificate if the certificate is
+ * self-signed) and add it to the set of certificates that are known to
+ * libcurl using CURLOPT_CAINFO and/or CURLOPT_CAPATH. See docs/SSLCERTS
+ * for more information. */
curl_easy_setopt(curl, CURLOPT_CAINFO, "/path/to/certificate.pem");
/* Since the traffic will be encrypted, it is very useful to turn on debug
if(curl) {
/* what URL that receives this POST */
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/examplepost.cgi");
- if ( (argc == 2) && (!strcmp(argv[1], "noexpectheader")) )
+ if((argc == 2) && (!strcmp(argv[1], "noexpectheader")))
/* only disable 100-continue header if explicitly requested */
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
/* error handling macros */
#define my_curl_easy_setopt(A, B, C) \
- if ((res = curl_easy_setopt((A), (B), (C))) != CURLE_OK) \
+ if((res = curl_easy_setopt((A), (B), (C))) != CURLE_OK) \
fprintf(stderr, "curl_easy_setopt(%s, %s, %s) failed: %d\n", \
#A, #B, #C, res);
#define my_curl_easy_perform(A) \
- if ((res = curl_easy_perform((A))) != CURLE_OK) \
+ if((res = curl_easy_perform((A))) != CURLE_OK) \
fprintf(stderr, "curl_easy_perform(%s) failed: %d\n", #A, res);
const char *sdp_filename)
{
CURLcode res = CURLE_OK;
- FILE *sdp_fp = fopen(sdp_filename, "wt");
+ FILE *sdp_fp = fopen(sdp_filename, "wb");
printf("\nRTSP: DESCRIBE %s\n", uri);
- if (sdp_fp == NULL) {
+ if(sdp_fp == NULL) {
fprintf(stderr, "Could not open '%s' for writing\n", sdp_filename);
sdp_fp = stdout;
}
my_curl_easy_setopt(curl, CURLOPT_RTSP_REQUEST, (long)CURL_RTSPREQ_DESCRIBE);
my_curl_easy_perform(curl);
my_curl_easy_setopt(curl, CURLOPT_WRITEDATA, stdout);
- if (sdp_fp != stdout) {
+ if(sdp_fp != stdout) {
fclose(sdp_fp);
}
}
/* convert url into an sdp filename */
-static void get_sdp_filename(const char *url, char *sdp_filename)
+static void get_sdp_filename(const char *url, char *sdp_filename,
+ size_t namelen)
{
const char *s = strrchr(url, '/');
strcpy(sdp_filename, "video.sdp");
- if (s != NULL) {
+ if(s != NULL) {
s++;
- if (s[0] != '\0') {
- sprintf(sdp_filename, "%s.sdp", s);
+ if(s[0] != '\0') {
+ snprintf(sdp_filename, namelen, "%s.sdp", s);
}
}
}
{
int max_len = 256;
char *s = malloc(max_len);
- FILE *sdp_fp = fopen(sdp_filename, "rt");
+ FILE *sdp_fp = fopen(sdp_filename, "rb");
control[0] = '\0';
- if (sdp_fp != NULL) {
- while (fgets(s, max_len - 2, sdp_fp) != NULL) {
+ if(sdp_fp != NULL) {
+ while(fgets(s, max_len - 2, sdp_fp) != NULL) {
sscanf(s, " a = control: %s", control);
}
fclose(sdp_fp);
#if 1
const char *transport = "RTP/AVP;unicast;client_port=1234-1235"; /* UDP */
#else
- const char *transport = "RTP/AVP/TCP;unicast;client_port=1234-1235"; /* TCP */
+ /* TCP */
+ const char *transport = "RTP/AVP/TCP;unicast;client_port=1234-1235";
#endif
const char *range = "0.000-";
int rc = EXIT_SUCCESS;
printf(" Requires cURL V7.20 or greater\n\n");
/* check command line */
- if ((argc != 2) && (argc != 3)) {
+ if((argc != 2) && (argc != 3)) {
base_name = strrchr(argv[0], '/');
- if (base_name == NULL) {
+ if(base_name == NULL) {
base_name = strrchr(argv[0], '\\');
}
- if (base_name == NULL) {
+ if(base_name == NULL) {
base_name = argv[0];
- } else {
+ }
+ else {
base_name++;
}
printf("Usage: %s url [transport]\n", base_name);
printf(" url of video server\n");
- printf(" transport (optional) specifier for media stream protocol\n");
+ printf(" transport (optional) specifier for media stream"
+ " protocol\n");
printf(" default transport: %s\n", transport);
printf("Example: %s rtsp://192.168.0.2/media/video1\n\n", base_name);
rc = EXIT_FAILURE;
- } else {
+ }
+ else {
const char *url = argv[1];
char *uri = malloc(strlen(url) + 32);
char *sdp_filename = malloc(strlen(url) + 32);
char *control = malloc(strlen(url) + 32);
CURLcode res;
- get_sdp_filename(url, sdp_filename);
- if (argc == 3) {
+ get_sdp_filename(url, sdp_filename, strlen(url) + 32);
+ if(argc == 3) {
transport = argv[2];
}
/* initialize curl */
res = curl_global_init(CURL_GLOBAL_ALL);
- if (res == CURLE_OK) {
+ if(res == CURLE_OK) {
curl_version_info_data *data = curl_version_info(CURLVERSION_NOW);
CURL *curl;
fprintf(stderr, " cURL V%s loaded\n", data->version);
/* initialize this curl session */
curl = curl_easy_init();
- if (curl != NULL) {
+ if(curl != NULL) {
my_curl_easy_setopt(curl, CURLOPT_VERBOSE, 0L);
my_curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
my_curl_easy_setopt(curl, CURLOPT_HEADERDATA, stdout);
my_curl_easy_setopt(curl, CURLOPT_URL, url);
/* request server options */
- sprintf(uri, "%s", url);
+ snprintf(uri, strlen(url) + 32, "%s", url);
rtsp_options(curl, uri);
/* request session description and write response to sdp file */
get_media_control_attribute(sdp_filename, control);
/* setup media stream */
- sprintf(uri, "%s/%s", url, control);
+ snprintf(uri, strlen(url) + 32, "%s/%s", url, control);
rtsp_setup(curl, uri, transport);
/* start playing media stream */
- sprintf(uri, "%s/", url);
+ snprintf(uri, strlen(url) + 32, "%s/", url);
rtsp_play(curl, uri, range);
printf("Playing video, press any key to stop ...");
_getch();
/* cleanup */
curl_easy_cleanup(curl);
curl = NULL;
- } else {
+ }
+ else {
fprintf(stderr, "curl_easy_init() failed\n");
}
curl_global_cleanup();
- } else {
+ }
+ else {
fprintf(stderr, "curl_global_init(%s) failed: %d\n",
"CURL_GLOBAL_ALL", res);
}
int rc;
tempptrin = tempptrout = buffer;
rc = platform_a2e(&tempptrin, &bytes, &tempptrout, &bytes);
- if (rc == PLATFORM_CONV_OK) {
- return(CURLE_OK);
- } else {
- return(CURLE_CONV_FAILED);
+ if(rc == PLATFORM_CONV_OK) {
+ return CURLE_OK;
+ }
+ else {
+ return CURLE_CONV_FAILED;
}
}
int rc;
tempptrin = tempptrout = buffer;
rc = platform_e2a(&tempptrin, &bytes, &tempptrout, &bytes);
- if (rc == PLATFORM_CONV_OK) {
- return(CURLE_OK);
- } else {
- return(CURLE_CONV_FAILED);
+ if(rc == PLATFORM_CONV_OK) {
+ return CURLE_OK;
+ }
+ else {
+ return CURLE_CONV_FAILED;
}
}
int rc;
tempptrin = tempptrout = buffer;
rc = platform_u2e(&tempptrin, &bytes, &tempptrout, &bytes);
- if (rc == PLATFORM_CONV_OK) {
- return(CURLE_OK);
- } else {
- return(CURLE_CONV_FAILED);
+ if(rc == PLATFORM_CONV_OK) {
+ return CURLE_OK;
+ }
+ else {
+ return CURLE_CONV_FAILED;
}
}
FD_SET(sockfd, &errfd); /* always check for error */
- if(for_recv)
- {
+ if(for_recv) {
FD_SET(sockfd, &infd);
}
- else
- {
+ else {
FD_SET(sockfd, &outfd);
}
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 1L);
res = curl_easy_perform(curl);
- if(CURLE_OK != res)
- {
+ if(CURLE_OK != res) {
printf("Error: %s\n", strerror(res));
return 1;
}
*/
res = curl_easy_getinfo(curl, CURLINFO_LASTSOCKET, &sockextr);
- if(CURLE_OK != res)
- {
+ if(CURLE_OK != res) {
printf("Error: %s\n", curl_easy_strerror(res));
return 1;
}
sockfd = sockextr;
/* wait for the socket to become ready for sending */
- if(!wait_on_socket(sockfd, 0, 60000L))
- {
+ if(!wait_on_socket(sockfd, 0, 60000L)) {
printf("Error: timeout.\n");
return 1;
}
* to see if all the request has been sent */
res = curl_easy_send(curl, request, strlen(request), &iolen);
- if(CURLE_OK != res)
- {
+ if(CURLE_OK != res) {
printf("Error: %s\n", curl_easy_strerror(res));
return 1;
}
puts("Reading response.");
/* read the response */
- for(;;)
- {
+ for(;;) {
char buf[1024];
wait_on_socket(sockfd, 1, 60000L);
static const char *pCertFile = "testcert.pem";
static const char *pCACertFile="cacert.pem";
+ static const char *pHeaderFile = "dumpit"
const char *pKeyName;
const char *pKeyType;
pEngine = NULL;
#endif
- headerfile = fopen("dumpit", "w");
+ headerfile = fopen(pHeaderFile, "wb");
curl_global_init(CURL_GLOBAL_DEFAULT);
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");
+ do { /* dummy 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 */
+ 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");
+ 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");
+ curl_easy_setopt(curl, CURLOPT_SSLCERTTYPE, "PEM");
/* set the cert for client authentication */
- curl_easy_setopt(curl,CURLOPT_SSLCERT,pCertFile);
+ 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(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);
+ curl_easy_setopt(curl, CURLOPT_SSLKEYTYPE, pKeyType);
/* set the private key (file or ID in engine) */
- curl_easy_setopt(curl,CURLOPT_SSLKEY,pKeyName);
+ curl_easy_setopt(curl, CURLOPT_SSLKEY, pKeyName);
/* set the file with the certs vaildating the server */
- curl_easy_setopt(curl,CURLOPT_CAINFO,pCACertFile);
+ curl_easy_setopt(curl, CURLOPT_CAINFO, pCACertFile);
/* disconnect if we can't validate server's cert */
- curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,1L);
+ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
/* Perform the request, res will get the return code */
res = curl_easy_perform(curl);
}
/* always cleanup */
curl_easy_cleanup(curl);
- }
+ } while(0);
curl_global_cleanup();
/* Stop threads from entering unless j is incremented */
pthread_mutex_lock(&lock);
- while ( j < num_urls )
- {
+ while(j < num_urls) {
printf("j = %d\n", j);
http =
printf( "http %s", http );
curl = curl_easy_init();
- if(curl)
- {
+ if(curl) {
- outfile = fopen(urls[j], "w");
- /* printf("fopen\n"); */
+ outfile = fopen(urls[j], "wb");
/* Set the URL and transfer type */
curl_easy_setopt(curl, CURLOPT_URL, http);
g_signal_connect(G_OBJECT (top_window), "delete-event",
G_CALLBACK(cb_delete), NULL);
- if (!g_thread_create(&create_thread, progress_bar, FALSE, NULL) != 0)
+ if(!g_thread_create(&create_thread, progress_bar, FALSE, NULL) != 0)
g_warning("can't create the thread");
gtk_main();
return 0;
}
-
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
"To: " TO "\r\n",
"From: " FROM "(Example User)\r\n",
"Cc: " CC "(Another example User)\r\n",
- "Message-ID: <dcd7cb36-11db-487a-9f3a-e652a9458efd@rfcpedant.example.org>\r\n",
+ "Message-ID: <dcd7cb36-11db-487a-9f3a-e652a9458efd@"
+ "rfcpedant.example.org>\r\n",
"Subject: SMTP example message\r\n",
"\r\n", /* empty line to divide headers from body, see RFC5322 */
"The body of the message starts here.\r\n",
/* This is the URL for your mailserver */
curl_easy_setopt(curl, CURLOPT_URL, "smtp://mail.example.com");
- /* Note that this option isn't strictly required, omitting it will result in
- * libcurl sending the MAIL FROM command with empty sender data. All
+ /* Note that this option isn't strictly required, omitting it will result
+ * in libcurl sending the MAIL FROM command with empty sender data. All
* autoresponses should have an empty reverse-path, and should be directed
- * to the address in the reverse-path which triggered them. Otherwise, they
- * could cause an endless loop. See RFC 5321 Section 4.5.5 for more details.
+ * to the address in the reverse-path which triggered them. Otherwise,
+ * they could cause an endless loop. See RFC 5321 Section 4.5.5 for more
+ * details.
*/
curl_easy_setopt(curl, CURLOPT_MAIL_FROM, FROM);
/* Free the list of recipients */
curl_slist_free_all(recipients);
- /* curl won't send the QUIT command until you call cleanup, so you should be
- * able to re-use this connection for additional messages (setting
+ /* curl won't send the QUIT command until you call cleanup, so you should
+ * be able to re-use this connection for additional messages (setting
* CURLOPT_MAIL_FROM and CURLOPT_MAIL_RCPT as required, and calling
* curl_easy_perform() again. It may not be a good idea to keep the
- * connection open for a very long time though (more than a few minutes may
- * result in the server timing out the connection), and you do want to clean
- * up in the end.
+ * connection open for a very long time though (more than a few minutes
+ * may result in the server timing out the connection), and you do want to
+ * clean up in the end.
*/
curl_easy_cleanup(curl);
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
"To: " TO "\r\n",
"From: " FROM "(Example User)\r\n",
"Cc: " CC "(Another example User)\r\n",
- "Message-ID: <dcd7cb36-11db-487a-9f3a-e652a9458efd@rfcpedant.example.org>\r\n",
+ "Message-ID: <dcd7cb36-11db-487a-9f3a-e652a9458efd@"
+ "rfcpedant.example.org>\r\n",
"Subject: SMTP multi example message\r\n",
"\r\n", /* empty line to divide headers from body, see RFC5322 */
"The body of the message starts here.\r\n",
/* get file descriptors from the transfers */
mc = curl_multi_fdset(mcurl, &fdread, &fdwrite, &fdexcep, &maxfd);
- if(mc != CURLM_OK)
- {
+ if(mc != CURLM_OK) {
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
"To: " TO "\r\n",
"From: " FROM "(Example User)\r\n",
"Cc: " CC "(Another example User)\r\n",
- "Message-ID: <dcd7cb36-11db-487a-9f3a-e652a9458efd@rfcpedant.example.org>\r\n",
+ "Message-ID: <dcd7cb36-11db-487a-9f3a-e652a9458efd@"
+ "rfcpedant.example.org>\r\n",
"Subject: SMTP SSL example message\r\n",
"\r\n", /* empty line to divide headers from body, see RFC5322 */
"The body of the message starts here.\r\n",
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
#endif
- /* Note that this option isn't strictly required, omitting it will result in
- * libcurl sending the MAIL FROM command with empty sender data. All
+ /* Note that this option isn't strictly required, omitting it will result
+ * in libcurl sending the MAIL FROM command with empty sender data. All
* autoresponses should have an empty reverse-path, and should be directed
- * to the address in the reverse-path which triggered them. Otherwise, they
- * could cause an endless loop. See RFC 5321 Section 4.5.5 for more details.
+ * to the address in the reverse-path which triggered them. Otherwise,
+ * they could cause an endless loop. See RFC 5321 Section 4.5.5 for more
+ * details.
*/
curl_easy_setopt(curl, CURLOPT_MAIL_FROM, FROM);
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
"To: " TO "\r\n",
"From: " FROM "(Example User)\r\n",
"Cc: " CC "(Another example User)\r\n",
- "Message-ID: <dcd7cb36-11db-487a-9f3a-e652a9458efd@rfcpedant.example.org>\r\n",
+ "Message-ID: <dcd7cb36-11db-487a-9f3a-e652a9458efd@"
+ "rfcpedant.example.org>\r\n",
"Subject: SMTP TLS example message\r\n",
"\r\n", /* empty line to divide headers from body, see RFC5322 */
"The body of the message starts here.\r\n",
* curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
* curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
* That is, in general, a bad idea. It is still better than sending your
- * authentication details in plain text though.
- * Instead, you should get the issuer certificate (or the host certificate
- * if the certificate is self-signed) and add it to the set of certificates
- * that are known to libcurl using CURLOPT_CAINFO and/or CURLOPT_CAPATH. See
- * docs/SSLCERTS for more information. */
+ * authentication details in plain text though. Instead, you should get
+ * the issuer certificate (or the host certificate if the certificate is
+ * self-signed) and add it to the set of certificates that are known to
+ * libcurl using CURLOPT_CAINFO and/or CURLOPT_CAPATH. See docs/SSLCERTS
+ * for more information. */
curl_easy_setopt(curl, CURLOPT_CAINFO, "/path/to/certificate.pem");
- /* Note that this option isn't strictly required, omitting it will result in
- * libcurl sending the MAIL FROM command with empty sender data. All
+ /* Note that this option isn't strictly required, omitting it will result
+ * in libcurl sending the MAIL FROM command with empty sender data. All
* autoresponses should have an empty reverse-path, and should be directed
- * to the address in the reverse-path which triggered them. Otherwise, they
- * could cause an endless loop. See RFC 5321 Section 4.5.5 for more details.
+ * to the address in the reverse-path which triggered them. Otherwise,
+ * they could cause an endless loop. See RFC 5321 Section 4.5.5 for more
+ * details.
*/
curl_easy_setopt(curl, CURLOPT_MAIL_FROM, FROM);
void *stream)
{
fwrite(ptr, size, nmemb, stream);
- return(nmemb*size);
+ return (nmemb*size);
}
size_t SyncTime_CURL_WriteHeader(void *ptr, size_t size, size_t nmemb,
int i, RetVal;
char TmpStr1[26], TmpStr2[26];
- if (ShowAllHeader == 1)
+ if(ShowAllHeader == 1)
fprintf(stderr, "%s", (char *)(ptr));
- if (strncmp((char *)(ptr), "Date:", 5) == 0) {
- if (ShowAllHeader == 0)
+ if(strncmp((char *)(ptr), "Date:", 5) == 0) {
+ if(ShowAllHeader == 0)
fprintf(stderr, "HTTP Server. %s", (char *)(ptr));
- if (AutoSyncTime == 1) {
+ if(AutoSyncTime == 1) {
*TmpStr1 = 0;
*TmpStr2 = 0;
- if (strlen((char *)(ptr)) > 50) /* Can prevent buffer overflow to
+ if(strlen((char *)(ptr)) > 50) /* Can prevent buffer overflow to
TmpStr1 & 2? */
AutoSyncTime = 0;
else {
TmpStr1, &SYSTime.wDay, TmpStr2, &SYSTime.wYear,
&SYSTime.wHour, &SYSTime.wMinute, &SYSTime.wSecond);
- if (RetVal == 7) {
-
+ if(RetVal == 7) {
SYSTime.wMilliseconds = 500; /* adjust to midpoint, 0.5 sec */
- for (i=0; i<12; i++) {
- if (strcmp(MthStr[i], TmpStr2) == 0) {
+ for(i=0; i<12; i++) {
+ if(strcmp(MthStr[i], TmpStr2) == 0) {
SYSTime.wMonth = i+1;
break;
}
}
}
- if (strncmp((char *)(ptr), "X-Cache: HIT", 12) == 0) {
+ if(strncmp((char *)(ptr), "X-Cache: HIT", 12) == 0) {
fprintf(stderr, "ERROR: HTTP Server data is cached."
" Server Date is no longer valid.\n");
AutoSyncTime = 0;
}
- return(nmemb*size);
+ return (nmemb*size);
}
void SyncTime_CURL_Init(CURL *curl, char *proxy_port,
char *proxy_user_password)
{
- if (strlen(proxy_port) > 0)
+ if(strlen(proxy_port) > 0)
curl_easy_setopt(curl, CURLOPT_PROXY, proxy_port);
- if (strlen(proxy_user_password) > 0)
+ if(strlen(proxy_user_password) > 0)
curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, proxy_user_password);
#ifdef SYNCTIME_UA
CURLcode res;
outfile = NULL;
- if (HttpGetBody == HTTP_COMMAND_HEAD)
+ if(HttpGetBody == HTTP_COMMAND_HEAD)
curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);
else {
outfile = fopen(OutFileName, "wb");
curl_easy_setopt(curl, CURLOPT_URL, URL_Str);
res = curl_easy_perform(curl);
- if (outfile != NULL)
+ if(outfile != NULL)
fclose(outfile);
return res; /* (CURLE_OK) */
}
int i;
*conf->http_proxy = 0;
- for (i=0; i<MAX_STRING1; i++)
+ for(i=0; i<MAX_STRING1; i++)
conf->proxy_user[i] = 0; /* Clean up password from memory */
*conf->timeserver = 0;
return 1;
RetValue = 0; /* Successful Exit */
conf_init(conf);
- if (argc > 1) {
- while (OptionIndex < argc) {
- if (strncmp(argv[OptionIndex], "--server=", 9) == 0)
+ if(argc > 1) {
+ while(OptionIndex < argc) {
+ if(strncmp(argv[OptionIndex], "--server=", 9) == 0)
snprintf(conf->timeserver, MAX_STRING, "%s", &argv[OptionIndex][9]);
- if (strcmp(argv[OptionIndex], "--showall") == 0)
+ if(strcmp(argv[OptionIndex], "--showall") == 0)
ShowAllHeader = 1;
- if (strcmp(argv[OptionIndex], "--synctime") == 0)
+ if(strcmp(argv[OptionIndex], "--synctime") == 0)
AutoSyncTime = 1;
- if (strncmp(argv[OptionIndex], "--proxy-user=", 13) == 0)
+ if(strncmp(argv[OptionIndex], "--proxy-user=", 13) == 0)
snprintf(conf->proxy_user, MAX_STRING, "%s", &argv[OptionIndex][13]);
- if (strncmp(argv[OptionIndex], "--proxy=", 8) == 0)
+ if(strncmp(argv[OptionIndex], "--proxy=", 8) == 0)
snprintf(conf->http_proxy, MAX_STRING, "%s", &argv[OptionIndex][8]);
- if ((strcmp(argv[OptionIndex], "--help") == 0) ||
+ if((strcmp(argv[OptionIndex], "--help") == 0) ||
(strcmp(argv[OptionIndex], "/?") == 0)) {
showUsage();
return 0;
}
}
- if (*conf->timeserver == 0) /* Use default server for time information */
+ if(*conf->timeserver == 0) /* Use default server for time information */
snprintf(conf->timeserver, MAX_STRING, "%s", DefaultTimeServer[0]);
/* Init CURL before usage */
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
- if (curl) {
+ if(curl) {
SyncTime_CURL_Init(curl, conf->http_proxy, conf->proxy_user);
/* Calculating time diff between GMT and localtime */
tzonediffFloat = difftime(tt_local, tt_gmt);
tzonediffWord = (int)(tzonediffFloat/3600.0);
- if ((double)(tzonediffWord * 3600) == tzonediffFloat)
+ if((double)(tzonediffWord * 3600) == tzonediffFloat)
snprintf(tzoneBuf, 15, "%+03d'00'", tzonediffWord);
else
snprintf(tzoneBuf, 15, "%+03d'30'", tzonediffWord);
LOCALTime.wMilliseconds);
fprintf(stderr, "\nAfter HTTP. Date: %s%s\n", timeBuf, tzoneBuf);
- if (AutoSyncTime == 3) {
+ if(AutoSyncTime == 3) {
/* Synchronising computer clock */
- if (!SetSystemTime(&SYSTime)) { /* Set system time */
+ if(!SetSystemTime(&SYSTime)) { /* Set system time */
fprintf(stderr, "ERROR: Unable to set system time.\n");
RetValue = 1;
}
{
(void)file;
(void)line;
- if (mode & CRYPTO_LOCK) {
+ if(mode & CRYPTO_LOCK) {
pthread_mutex_lock(&(lockarray[type]));
}
else {
unsigned long ret;
ret=(unsigned long)pthread_self();
- return(ret);
+ return ret;
}
static void init_locks(void)
lockarray=(pthread_mutex_t *)OPENSSL_malloc(CRYPTO_num_locks() *
sizeof(pthread_mutex_t));
- for (i=0; i<CRYPTO_num_locks(); i++) {
- pthread_mutex_init(&(lockarray[i]),NULL);
+ for(i=0; i<CRYPTO_num_locks(); i++) {
+ pthread_mutex_init(&(lockarray[i]), NULL);
}
CRYPTO_set_id_callback((unsigned long (*)())thread_id);
int i;
CRYPTO_set_locking_callback(NULL);
- for (i=0; i<CRYPTO_num_locks(); i++)
+ for(i=0; i<CRYPTO_num_locks(); i++)
pthread_mutex_destroy(&(lockarray[i]));
OPENSSL_free(lockarray);
/* open the file */
pagefile = fopen(pagefilename, "wb");
- if (pagefile) {
+ if(pagefile) {
/* write the page body to this file handle */
curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, pagefile);
static size_t writefunction(void *ptr, size_t size, size_t nmemb, void *stream)
{
- fwrite(ptr,size,nmemb,stream);
- return(nmemb*size);
+ fwrite(ptr, size, nmemb, stream);
+ return (nmemb*size);
}
static CURLcode sslctx_function(CURL *curl, void *sslctx, void *parm)
/* get a BIO */
bio = BIO_new_mem_buf((char *)mypem, -1);
- if (bio == NULL) {
+ if(bio == NULL) {
printf("BIO_new_mem_buf failed\n");
}
* structure that SSL can use
*/
cert = PEM_read_bio_X509(bio, NULL, 0, NULL);
- if (cert == NULL) {
+ if(cert == NULL) {
printf("PEM_read_bio_X509 failed...\n");
}
/*tell SSL to use the X509 certificate*/
ret = SSL_CTX_use_certificate((SSL_CTX*)sslctx, cert);
- if (ret != 1) {
+ if(ret != 1) {
printf("Use certificate failed\n");
}
/*create a bio for the RSA key*/
kbio = BIO_new_mem_buf((char *)mykey, -1);
- if (kbio == NULL) {
+ if(kbio == NULL) {
printf("BIO_new_mem_buf failed\n");
}
/*read the key bio into an RSA object*/
rsa = PEM_read_bio_RSAPrivateKey(kbio, NULL, 0, NULL);
- if (rsa == NULL) {
+ if(rsa == NULL) {
printf("Failed to create key bio\n");
}
/*tell SSL to use the RSA key from memory*/
ret = SSL_CTX_use_RSAPrivateKey((SSL_CTX*)sslctx, rsa);
- if (ret != 1) {
+ if(ret != 1) {
printf("Use Key failed\n");
}
/* free resources that have been allocated by openssl functions */
- if (bio)
+ if(bio)
BIO_free(bio);
- if (kbio)
+ if(kbio)
BIO_free(kbio);
- if (rsa)
+ if(rsa)
RSA_free(rsa);
- if (cert)
+ if(cert)
X509_free(cert);
/* all set to go */
- return CURLE_OK ;
+ return CURLE_OK;
}
int main(void)
rv = curl_global_init(CURL_GLOBAL_ALL);
ch = curl_easy_init();
- rv = curl_easy_setopt(ch,CURLOPT_VERBOSE, 0L);
- rv = curl_easy_setopt(ch,CURLOPT_HEADER, 0L);
- rv = curl_easy_setopt(ch,CURLOPT_NOPROGRESS, 1L);
- rv = curl_easy_setopt(ch,CURLOPT_NOSIGNAL, 1L);
- rv = curl_easy_setopt(ch,CURLOPT_WRITEFUNCTION, *writefunction);
- rv = curl_easy_setopt(ch,CURLOPT_WRITEDATA, stdout);
- rv = curl_easy_setopt(ch,CURLOPT_HEADERFUNCTION, *writefunction);
- rv = curl_easy_setopt(ch,CURLOPT_HEADERDATA, stderr);
- rv = curl_easy_setopt(ch,CURLOPT_SSLCERTTYPE,"PEM");
+ rv = curl_easy_setopt(ch, CURLOPT_VERBOSE, 0L);
+ rv = curl_easy_setopt(ch, CURLOPT_HEADER, 0L);
+ rv = curl_easy_setopt(ch, CURLOPT_NOPROGRESS, 1L);
+ rv = curl_easy_setopt(ch, CURLOPT_NOSIGNAL, 1L);
+ rv = curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, writefunction);
+ rv = curl_easy_setopt(ch, CURLOPT_WRITEDATA, stdout);
+ rv = curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, writefunction);
+ rv = curl_easy_setopt(ch, CURLOPT_HEADERDATA, stderr);
+ rv = curl_easy_setopt(ch, CURLOPT_SSLCERTTYPE, "PEM");
/* both VERIFYPEER and VERIFYHOST are set to 0 in this case because there is
no CA certificate*/
- rv = curl_easy_setopt(ch,CURLOPT_SSL_VERIFYPEER, 0L);
- rv = curl_easy_setopt(ch,CURLOPT_SSL_VERIFYHOST, 0L);
+ rv = curl_easy_setopt(ch, CURLOPT_SSL_VERIFYPEER, 0L);
+ rv = curl_easy_setopt(ch, CURLOPT_SSL_VERIFYHOST, 0L);
rv = curl_easy_setopt(ch, CURLOPT_URL, "https://www.example.com/");
rv = curl_easy_setopt(ch, CURLOPT_SSLKEYTYPE, "PEM");
/* first try: retrieve page without user certificate and key -> will fail
*/
rv = curl_easy_perform(ch);
- if (rv==CURLE_OK) {
+ if(rv==CURLE_OK) {
printf("*** transfer succeeded ***\n");
}
else {
* load the certificate and key by installing a function doing the necessary
* "modifications" to the SSL CONTEXT just before link init
*/
- rv = curl_easy_setopt(ch,CURLOPT_SSL_CTX_FUNCTION, *sslctx_function);
+ rv = curl_easy_setopt(ch, CURLOPT_SSL_CTX_FUNCTION, *sslctx_function);
rv = curl_easy_perform(ch);
- if (rv==CURLE_OK) {
+ if(rv==CURLE_OK) {
printf("*** transfer succeeded ***\n");
}
else {
struct MemoryStruct characters;
};
-static void startElement(void *userData, const XML_Char *name, const XML_Char **atts)
+static void startElement(void *userData, const XML_Char *name,
+ const XML_Char **atts)
{
struct ParserStruct *state = (struct ParserStruct *) userData;
state->tags++;
printf("%5lu %10lu %s\n", state->depth, state->characters.size, name);
}
-static size_t parseStreamCallback(void *contents, size_t length, size_t nmemb, void *userp)
+static size_t parseStreamCallback(void *contents, size_t length, size_t nmemb,
+ void *userp)
{
XML_Parser parser = (XML_Parser) userp;
size_t real_size = length * nmemb;
struct ParserStruct *state = (struct ParserStruct *) XML_GetUserData(parser);
/* Only parse if we're not already in a failure state. */
- if (state->ok && XML_Parse(parser, contents, real_size, 0) == 0) {
+ if(state->ok && XML_Parse(parser, contents, real_size, 0) == 0) {
int error_code = XML_GetErrorCode(parser);
- fprintf(stderr, "Parsing response buffer of length %lu failed with error code %d (%s).\n",
+ fprintf(stderr, "Parsing response buffer of length %lu failed"
+ " with error code %d (%s).\n",
real_size, error_code, XML_ErrorString(error_code));
state->ok = 0;
}
/* Initialize a libcurl handle. */
curl_global_init(CURL_GLOBAL_ALL ^ CURL_GLOBAL_SSL);
curl_handle = curl_easy_init();
- curl_easy_setopt(curl_handle, CURLOPT_URL, "http://www.w3schools.com/xml/simple.xml");
+ curl_easy_setopt(curl_handle, CURLOPT_URL,
+ "http://www.w3schools.com/xml/simple.xml");
curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, parseStreamCallback);
curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)parser);
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
- else if (state.ok) {
+ else if(state.ok) {
/* Expat requires one final call to finalize parsing. */
- if (XML_Parse(parser, NULL, 0, 1) == 0) {
+ if(XML_Parse(parser, NULL, 0, 1) == 0) {
int error_code = XML_GetErrorCode(parser);
fprintf(stderr, "Finalizing parsing failed with error code %d (%s).\n",
error_code, XML_ErrorString(error_code));
projects / curl / commitdiff