Also: make them C89, add consts.
Closes #15785
{
CURLcode rv = CURLE_ABORTED_BY_CALLBACK;
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverlength-strings"
+#endif
+
/** This example uses two (fake) certificates **/
static const char mypem[] =
"-----BEGIN CERTIFICATE-----\n"
"Z05phkOTOPu220+DkdRgfks+KzgHVZhepA==\n"
"-----END CERTIFICATE-----\n";
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
BIO *cbio = BIO_new_mem_buf(mypem, sizeof(mypem));
X509_STORE *cts = SSL_CTX_get_cert_store((SSL_CTX *)sslctx);
int i;
curl_easy_cleanup(ch);
curl_global_cleanup();
- return rv;
+ return (int)rv;
}
* </DESC>
*/
-/* Parameters */
-int max_con = 200;
-int max_total = 20000;
-int max_requests = 500;
-int max_link_per_page = 5;
-int follow_relative_links = 0;
-char *start_page = "https://www.reuters.com";
-
#include <libxml/HTMLparser.h>
#include <libxml/xpath.h>
#include <libxml/uri.h>
#include <math.h>
#include <signal.h>
-int pending_interrupt = 0;
-void sighandler(int dummy)
+/* Parameters */
+static int max_con = 200;
+static int max_total = 20000;
+static int max_requests = 500;
+static size_t max_link_per_page = 5;
+static int follow_relative_links = 0;
+static const char *start_page = "https://www.reuters.com";
+
+static int pending_interrupt = 0;
+static void sighandler(int dummy)
{
+ (void)dummy;
pending_interrupt = 1;
}
size_t size;
} memory;
-size_t grow_buffer(void *contents, size_t sz, size_t nmemb, void *ctx)
+static size_t grow_buffer(void *contents, size_t sz, size_t nmemb, void *ctx)
{
size_t realsize = sz * nmemb;
memory *mem = (memory*) ctx;
return realsize;
}
-CURL *make_handle(char *url)
+static CURL *make_handle(const char *url)
{
CURL *handle = curl_easy_init();
+ memory *mem;
/* Important: use HTTP2 over HTTPS */
curl_easy_setopt(handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
curl_easy_setopt(handle, CURLOPT_URL, url);
/* buffer body */
- memory *mem = malloc(sizeof(memory));
+ mem = malloc(sizeof(memory));
mem->size = 0;
mem->buf = malloc(1);
curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, grow_buffer);
}
/* HREF finder implemented in libxml2 but could be any HTML parser */
-size_t follow_links(CURLM *multi_handle, memory *mem, char *url)
+static size_t follow_links(CURLM *multi_handle, memory *mem, const char *url)
{
int opts = HTML_PARSE_NOBLANKS | HTML_PARSE_NOERROR | \
HTML_PARSE_NOWARNING | HTML_PARSE_NONET;
- htmlDocPtr doc = htmlReadMemory(mem->buf, mem->size, url, NULL, opts);
+ htmlDocPtr doc = htmlReadMemory(mem->buf, (int)mem->size, url, NULL, opts);
+ size_t count;
+ int i;
+ xmlChar *xpath;
+ xmlNodeSetPtr nodeset;
+ xmlXPathContextPtr context;
+ xmlXPathObjectPtr result;
if(!doc)
return 0;
- xmlChar *xpath = (xmlChar*) "//a/@href";
- xmlXPathContextPtr context = xmlXPathNewContext(doc);
- xmlXPathObjectPtr result = xmlXPathEvalExpression(xpath, context);
+ xpath = (xmlChar*) "//a/@href";
+ context = xmlXPathNewContext(doc);
+ result = xmlXPathEvalExpression(xpath, context);
xmlXPathFreeContext(context);
if(!result)
return 0;
- xmlNodeSetPtr nodeset = result->nodesetval;
+ nodeset = result->nodesetval;
if(xmlXPathNodeSetIsEmpty(nodeset)) {
xmlXPathFreeObject(result);
return 0;
}
- size_t count = 0;
- int i;
+ count = 0;
for(i = 0; i < nodeset->nodeNr; i++) {
double r = rand();
- int x = r * nodeset->nodeNr / RAND_MAX;
+ int x = (int)(r * nodeset->nodeNr / RAND_MAX);
const xmlNode *node = nodeset->nodeTab[x]->xmlChildrenNode;
xmlChar *href = xmlNodeListGetString(doc, node, 1);
+ char *link;
if(follow_relative_links) {
xmlChar *orig = href;
href = xmlBuildURI(href, (xmlChar *) url);
xmlFree(orig);
}
- char *link = (char *) href;
+ link = (char *) href;
if(!link || strlen(link) < 20)
continue;
if(!strncmp(link, "http://", 7) || !strncmp(link, "https://", 8)) {
return count;
}
-int is_html(char *ctype)
+static int is_html(char *ctype)
{
return ctype != NULL && strlen(ctype) > 10 && strstr(ctype, "text/html");
}
int main(void)
{
+ CURLM *multi_handle;
+ int msgs_left;
+ int pending;
+ int complete;
+ int still_running;
+
signal(SIGINT, sighandler);
- LIBXML_TEST_VERSION;
+ LIBXML_TEST_VERSION
curl_global_init(CURL_GLOBAL_DEFAULT);
- CURLM *multi_handle = curl_multi_init();
+ multi_handle = curl_multi_init();
curl_multi_setopt(multi_handle, CURLMOPT_MAX_TOTAL_CONNECTIONS, max_con);
curl_multi_setopt(multi_handle, CURLMOPT_MAX_HOST_CONNECTIONS, 6L);
/* sets html start page */
curl_multi_add_handle(multi_handle, make_handle(start_page));
- int msgs_left;
- int pending = 0;
- int complete = 0;
- int still_running = 1;
+ pending = 0;
+ complete = 0;
+ still_running = 1;
while(still_running && !pending_interrupt) {
int numfds;
+ CURLMsg *m;
+
curl_multi_wait(multi_handle, NULL, 0, 1000, &numfds);
curl_multi_perform(multi_handle, &still_running);
/* See how the transfers went */
- CURLMsg *m = NULL;
+ m = NULL;
while((m = curl_multi_info_read(multi_handle, &msgs_left))) {
if(m->msg == CURLMSG_DONE) {
CURL *handle = m->easy_handle;
/* Create a new easy handle, and add it to the global curl_multi */
-static void new_conn(char *url, GlobalInfo *g)
+static void new_conn(const char *url, GlobalInfo *g)
{
ConnInfo *conn;
CURLMcode rc;
conn = (ConnInfo*)calloc(1, sizeof(ConnInfo));
- conn->error[0]='\0';
+ conn->error[0] = '\0';
conn->easy = curl_easy_init();
if(!conn->easy) {
#include <sys/stat.h>
#include <errno.h>
-#define DPRINT(x...) printf(x)
-
#define MSG_OUT stdout /* Send info to stdout, change to stderr if you want */
/* Update the event timer after curl_multi library calls */
static int multi_timer_cb(CURLM *multi, long timeout_ms, GlobalInfo *g)
{
- DPRINT("%s %li\n", __PRETTY_FUNCTION__, timeout_ms);
+ (void)multi;
+ printf("%s %li\n", __PRETTY_FUNCTION__, timeout_ms);
ev_timer_stop(g->loop, &g->timer_event);
if(timeout_ms >= 0) {
/* -1 means delete, other values are timeout times in milliseconds */
/* Called by libevent when we get action on a multi socket */
static void event_cb(EV_P_ struct ev_io *w, int revents)
{
- DPRINT("%s w %p revents %i\n", __PRETTY_FUNCTION__, w, revents);
- GlobalInfo *g = (GlobalInfo*) w->data;
+ GlobalInfo *g;
CURLMcode rc;
+ int action;
+
+ printf("%s w %p revents %i\n", __PRETTY_FUNCTION__, (void *)w, revents);
+ g = (GlobalInfo*) w->data;
- int action = ((revents & EV_READ) ? CURL_POLL_IN : 0) |
- ((revents & EV_WRITE) ? CURL_POLL_OUT : 0);
+ action = ((revents & EV_READ) ? CURL_POLL_IN : 0) |
+ ((revents & EV_WRITE) ? CURL_POLL_OUT : 0);
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);
/* Called by libevent when our timeout expires */
static void timer_cb(EV_P_ struct ev_timer *w, int revents)
{
- DPRINT("%s w %p revents %i\n", __PRETTY_FUNCTION__, w, revents);
-
- GlobalInfo *g = (GlobalInfo *)w->data;
+ GlobalInfo *g;
CURLMcode rc;
+ printf("%s w %p revents %i\n", __PRETTY_FUNCTION__, (void *)w, revents);
+
+ g = (GlobalInfo *)w->data;
+
rc = curl_multi_socket_action(g->multi, CURL_SOCKET_TIMEOUT, 0,
&g->still_running);
mcode_or_die("timer_cb: curl_multi_socket_action", rc);
static void setsock(SockInfo *f, curl_socket_t s, CURL *e, int act,
GlobalInfo *g)
{
- printf("%s \n", __PRETTY_FUNCTION__);
-
int kind = ((act & CURL_POLL_IN) ? EV_READ : 0) |
((act & CURL_POLL_OUT) ? EV_WRITE : 0);
+ printf("%s \n", __PRETTY_FUNCTION__);
+
f->sockfd = s;
f->action = act;
f->easy = e;
/* CURLMOPT_SOCKETFUNCTION */
static int sock_cb(CURL *e, curl_socket_t s, int what, void *cbp, void *sockp)
{
- DPRINT("%s e %p s %i what %i cbp %p sockp %p\n",
- __PRETTY_FUNCTION__, e, s, what, cbp, sockp);
-
GlobalInfo *g = (GlobalInfo*) cbp;
SockInfo *fdp = (SockInfo*) sockp;
const char *whatstr[]={ "none", "IN", "OUT", "INOUT", "REMOVE"};
+ printf("%s e %p s %i what %i cbp %p sockp %p\n",
+ __PRETTY_FUNCTION__, e, s, what, cbp, sockp);
+
fprintf(MSG_OUT,
"socket callback: s=%d e=%p what=%s ", s, e, whatstr[what]);
if(what == CURL_POLL_REMOVE) {
return realsize;
}
-
-/* CURLOPT_PROGRESSFUNCTION */
-static int prog_cb(void *p, double dltotal, double dlnow, double ult,
- double uln)
+/* CURLOPT_XFERINFOFUNCTION */
+static int xferinfo_cb(void *p, curl_off_t dltotal, curl_off_t dlnow,
+ curl_off_t ult, curl_off_t uln)
{
ConnInfo *conn = (ConnInfo *)p;
(void)ult;
(void)uln;
- fprintf(MSG_OUT, "Progress: %s (%g/%g)\n", conn->url, dlnow, dltotal);
+ fprintf(MSG_OUT, "Progress: %s (%" CURL_FORMAT_CURL_OFF_T
+ "/%" CURL_FORMAT_CURL_OFF_T ")\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)
+static void new_conn(const char *url, GlobalInfo *g)
{
ConnInfo *conn;
CURLMcode rc;
curl_easy_setopt(conn->easy, CURLOPT_ERRORBUFFER, conn->error);
curl_easy_setopt(conn->easy, CURLOPT_PRIVATE, conn);
curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, 0L);
- curl_easy_setopt(conn->easy, CURLOPT_PROGRESSFUNCTION, prog_cb);
+ curl_easy_setopt(conn->easy, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
curl_easy_setopt(conn->easy, CURLOPT_PROGRESSDATA, conn);
curl_easy_setopt(conn->easy, CURLOPT_LOW_SPEED_TIME, 3L);
curl_easy_setopt(conn->easy, CURLOPT_LOW_SPEED_LIMIT, 10L);
int n = 0;
GlobalInfo *g = (GlobalInfo *)w->data;
+ (void)revents;
+
do {
s[0]='\0';
rv = fscanf(g->input, "%1023s%n", s, &n);
/* Check for completed transfers, and remove their easy handles */
static void check_multi_info(GlobalInfo *g)
{
- char *eff_url;
CURLMsg *msg;
int msgs_left;
- ConnInfo *conn;
- CURL *easy;
- 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) {
- easy = msg->easy_handle;
- res = msg->data.result;
+ CURL *easy = msg->easy_handle;
+ CURLcode res = msg->data.result;
+ char *eff_url;
+ ConnInfo *conn;
curl_easy_getinfo(easy, CURLINFO_PRIVATE, &conn);
curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url);
MSG_OUT("DONE: %s => (%d) %s\n", eff_url, res, conn->error);
return realsize;
}
-/* CURLOPT_PROGRESSFUNCTION */
-static int prog_cb(void *p, double dltotal, double dlnow, double ult,
- double uln)
+/* CURLOPT_XFERINFOFUNCTION */
+static int xferinfo_cb(void *p, curl_off_t dltotal, curl_off_t dlnow,
+ curl_off_t ult, curl_off_t uln)
{
ConnInfo *conn = (ConnInfo *)p;
- MSG_OUT("Progress: %s (%g/%g)\n", conn->url, dlnow, dltotal);
+ (void)ult;
+ (void)uln;
+
+ fprintf(MSG_OUT, "Progress: %s (%" CURL_FORMAT_CURL_OFF_T
+ "/%" CURL_FORMAT_CURL_OFF_T ")\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)
+static void new_conn(const char *url, GlobalInfo *g)
{
ConnInfo *conn;
CURLMcode rc;
conn = g_malloc0(sizeof(ConnInfo));
- conn->error[0]='\0';
+ conn->error[0] = '\0';
conn->easy = curl_easy_init();
if(!conn->easy) {
MSG_OUT("curl_easy_init() failed, exiting!\n");
curl_easy_setopt(conn->easy, CURLOPT_ERRORBUFFER, conn->error);
curl_easy_setopt(conn->easy, CURLOPT_PRIVATE, conn);
curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, SHOW_PROGRESS ? 0L : 1L);
- curl_easy_setopt(conn->easy, CURLOPT_PROGRESSFUNCTION, prog_cb);
+ curl_easy_setopt(conn->easy, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
curl_easy_setopt(conn->easy, CURLOPT_PROGRESSDATA, conn);
curl_easy_setopt(conn->easy, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(conn->easy, CURLOPT_CONNECTTIMEOUT, 30L);
const char *fifo = "hiper.fifo";
int socket;
- if(lstat (fifo, &st) == 0) {
+ if(lstat(fifo, &st) == 0) {
if((st.st_mode & S_IFMT) == S_IFREG) {
errno = EEXIST;
perror("lstat");
return socket;
}
-int main(int argc, char **argv)
+int main(void)
{
- GlobalInfo *g;
+ GlobalInfo *g = g_malloc0(sizeof(GlobalInfo));
GMainLoop*gmain;
int fd;
GIOChannel* ch;
- g = g_malloc0(sizeof(GlobalInfo));
fd = init_fifo();
ch = g_io_channel_unix_new(fd);
if(event_initialized(&f->ev)) {
event_del(&f->ev);
}
- event_assign(&f->ev, g->evbase, f->sockfd, kind, event_cb, g);
+ event_assign(&f->ev, g->evbase, f->sockfd, (short)kind, event_cb, g);
event_add(&f->ev, NULL);
}
/* CURLOPT_PROGRESSFUNCTION */
-static int prog_cb(void *p, double dltotal, double dlnow, double ult,
- double uln)
+static int xferinfo_cb(void *p, curl_off_t dltotal, curl_off_t dlnow,
+ curl_off_t ult, curl_off_t uln)
{
ConnInfo *conn = (ConnInfo *)p;
(void)ult;
(void)uln;
- fprintf(MSG_OUT, "Progress: %s (%g/%g)\n", conn->url, dlnow, dltotal);
+ fprintf(MSG_OUT, "Progress: %s (%" CURL_FORMAT_CURL_OFF_T
+ "/%" CURL_FORMAT_CURL_OFF_T ")\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)
+static void new_conn(const char *url, GlobalInfo *g)
{
ConnInfo *conn;
CURLMcode rc;
conn = calloc(1, sizeof(ConnInfo));
- conn->error[0]='\0';
+ conn->error[0] = '\0';
conn->easy = curl_easy_init();
if(!conn->easy) {
curl_easy_setopt(conn->easy, CURLOPT_ERRORBUFFER, conn->error);
curl_easy_setopt(conn->easy, CURLOPT_PRIVATE, conn);
curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, 0L);
- curl_easy_setopt(conn->easy, CURLOPT_PROGRESSFUNCTION, prog_cb);
+ curl_easy_setopt(conn->easy, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
curl_easy_setopt(conn->easy, CURLOPT_PROGRESSDATA, conn);
curl_easy_setopt(conn->easy, CURLOPT_FOLLOWLOCATION, 1L);
fprintf(MSG_OUT,
// Case-insensitive string comparison
//
-#ifdef _MSC_VER
+#ifdef _WIN32
#define COMPARE(a, b) (!_stricmp((a), (b)))
#else
#define COMPARE(a, b) (!strcasecmp((a), (b)))
// libcurl write callback function
//
-static int writer(char *data, size_t size, size_t nmemb,
- std::string *writerData)
+static size_t writer(char *data, size_t size, size_t nmemb,
+ std::string *writerData)
{
if(writerData == NULL)
return 0;
// libcurl connection initialization
//
-static bool init(CURL *&conn, char *url)
+static bool init(CURL *&conn, const char *url)
{
CURLcode code;
{
Context *context = static_cast<Context *>(voidContext);
- if(COMPARE(reinterpret_cast<char *>(name), "TITLE")) {
+ if(COMPARE(reinterpret_cast<const char *>(name), "TITLE")) {
context->title = "";
context->addTitle = true;
}
{
Context *context = static_cast<Context *>(voidContext);
- if(COMPARE(reinterpret_cast<char *>(name), "TITLE"))
+ if(COMPARE(reinterpret_cast<const char *>(name), "TITLE"))
context->addTitle = false;
}
int length)
{
if(context->addTitle)
- context->title.append(reinterpret_cast<char *>(chars), length);
+ context->title.append(reinterpret_cast<const char *>(chars),
+ (unsigned long)length);
}
//
NULL,
NULL,
cdata,
+ NULL,
+ 0,
+ 0,
+ 0,
+ 0,
NULL
};
ctxt = htmlCreatePushParserCtxt(&saxHandler, &context, "", 0, "",
XML_CHAR_ENCODING_NONE);
- htmlParseChunk(ctxt, html.c_str(), html.size(), 0);
+ htmlParseChunk(ctxt, html.c_str(), (int)html.size(), 0);
htmlParseChunk(ctxt, "", 0, 1);
htmlFreeParserCtxt(ctxt);
#include <event2/event.h>
#include <curl/curl.h>
-struct event_base *base;
-CURLM *curl_handle;
-struct event *timeout;
+static struct event_base *base;
+static CURLM *curl_handle;
+static struct event *timeout;
typedef struct curl_context_s {
struct event *event;
int flags = 0;
curl_context_t *context;
+ (void)fd;
+
if(event & EV_READ)
flags |= CURL_CSELECT_IN;
if(event & EV_WRITE)
static void on_timeout(evutil_socket_t fd, short events, void *arg)
{
int running_handles;
+ (void)fd;
+ (void)events;
+ (void)arg;
curl_multi_socket_action(curl_handle, CURL_SOCKET_TIMEOUT, 0,
&running_handles);
check_multi_info();
static int start_timeout(CURLM *multi, long timeout_ms, void *userp)
{
+ (void)multi;
+ (void)userp;
if(timeout_ms < 0) {
evtimer_del(timeout);
}
else {
+ struct timeval tv;
if(timeout_ms == 0)
timeout_ms = 1; /* 0 means call socket_action asap */
- struct timeval tv;
tv.tv_sec = timeout_ms / 1000;
tv.tv_usec = (timeout_ms % 1000) * 1000;
evtimer_del(timeout);
}
static int handle_socket(CURL *easy, curl_socket_t s, int action, void *userp,
- void *socketp)
+ void *socketp)
{
curl_context_t *curl_context;
int events = 0;
+ (void)easy;
+ (void)userp;
+
switch(action) {
case CURL_POLL_IN:
case CURL_POLL_OUT:
events |= EV_PERSIST;
event_del(curl_context->event);
- event_assign(curl_context->event, base, curl_context->sockfd, events,
- curl_perform, curl_context);
+ event_assign(curl_context->event, base, curl_context->sockfd,
+ (short)events, curl_perform, curl_context);
event_add(curl_context->event, NULL);
break;
if(timeout_ms == 0)
timeout_ms = 1; /* 0 means call curl_multi_socket_action asap but NOT
within the callback itself */
- uv_timer_start(&uv->timeout, on_uv_timeout, timeout_ms,
+ uv_timer_start(&uv->timeout, on_uv_timeout, (uint64_t)timeout_ms,
0); /* do not repeat */
}
return 0;
https://curl.se/libcurl/c/threadsafe.html
*/
-const char * const urls[NUMT]= {
+static const char * const urls[NUMT]= {
"https://curl.se/",
"ftp://example.com/",
"https://example.net/",
void * (*start_func)(void *), void *arg);
*/
-int main(int argc, char **argv)
+int main(void)
{
pthread_t tid[NUMT];
int i;
(void)stream;
(void)ptr;
- res = curl_easy_getinfo(curl, CURLINFO_TLS_SESSION, &info);
+ res = CURL_IGNORE_DEPRECATION(
+ curl_easy_getinfo(curl, CURLINFO_TLS_SESSION, &info));
if(!res) {
switch(info->backend) {
#ifdef _WIN32
#include <windows.h>
+#else
+#error "This example requires Windows."
#endif
char timeserver[MAX_STRING1];
} conf_t;
-const char DefaultTimeServer[3][MAX_STRING1] =
+static const char DefaultTimeServer[3][MAX_STRING1] =
{
"https://nist.time.gov/",
"https://www.google.com/"
};
-const char *DayStr[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-const char *MthStr[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
- "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+static const char *DayStr[] = {
+ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+static const char *MthStr[] = {
+ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-int ShowAllHeader;
-int AutoSyncTime;
-SYSTEMTIME SYSTime;
-SYSTEMTIME LOCALTime;
+static int ShowAllHeader;
+static int AutoSyncTime;
+static SYSTEMTIME SYSTime;
+static SYSTEMTIME LOCALTime;
#define HTTP_COMMAND_HEAD 0
#define HTTP_COMMAND_GET 1
-size_t SyncTime_CURL_WriteOutput(void *ptr, size_t size, size_t nmemb,
- void *stream)
+static size_t SyncTime_CURL_WriteOutput(void *ptr, size_t size, size_t nmemb,
+ void *stream)
{
fwrite(ptr, size, nmemb, stream);
return (nmemb*size);
}
-size_t SyncTime_CURL_WriteHeader(void *ptr, size_t size, size_t nmemb,
- void *stream)
+static size_t SyncTime_CURL_WriteHeader(void *ptr, size_t size, size_t nmemb,
+ void *stream)
{
- char TmpStr1[26], TmpStr2[26];
+ char TmpStr1[26], TmpStr2[26];
(void)stream;
SYSTime.wMilliseconds = 500; /* adjust to midpoint, 0.5 sec */
for(i = 0; i < 12; i++) {
if(strcmp(MthStr[i], TmpStr2) == 0) {
- SYSTime.wMonth = i + 1;
+ SYSTime.wMonth = (WORD)(i + 1);
break;
}
}
return (nmemb*size);
}
-void SyncTime_CURL_Init(CURL *curl, char *proxy_port,
- char *proxy_user_password)
+static void SyncTime_CURL_Init(CURL *curl, const char *proxy_port,
+ const char *proxy_user_password)
{
if(strlen(proxy_port) > 0)
curl_easy_setopt(curl, CURLOPT_PROXY, proxy_port);
if(strlen(proxy_user_password) > 0)
curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, proxy_user_password);
-#ifdef SYNCTIME_UA
curl_easy_setopt(curl, CURLOPT_USERAGENT, SYNCTIME_UA);
-#endif
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, SyncTime_CURL_WriteOutput);
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, SyncTime_CURL_WriteHeader);
}
-int SyncTime_CURL_Fetch(CURL *curl, char *URL_Str, char *OutFileName,
- int HttpGetBody)
+static CURLcode SyncTime_CURL_Fetch(CURL *curl, const char *URL_Str,
+ const char *OutFileName, int HttpGetBody)
{
FILE *outfile;
CURLcode res;
return res; /* (CURLE_OK) */
}
-void showUsage(void)
+static void showUsage(void)
{
- fprintf(stderr, "SYNCTIME: Synchronising computer clock with time server"
+ fprintf(stderr, "synctime: Synchronising computer clock with time server"
" using HTTP protocol.\n");
- fprintf(stderr, "Usage : SYNCTIME [Option]\n");
+ fprintf(stderr, "Usage : synctime [Option]\n");
fprintf(stderr, "Options :\n");
fprintf(stderr, " --server=WEBSERVER Use this time server instead"
" of default.\n");
return;
}
-int conf_init(conf_t *conf)
+static int conf_init(conf_t *conf)
{
int i;
tzonediffWord = (int)(tzonediffFloat/3600.0);
if((double)(tzonediffWord * 3600) == tzonediffFloat)
- snprintf(tzoneBuf, 15, "%+03d'00'", tzonediffWord);
+ snprintf(tzoneBuf, sizeof(tzoneBuf), "%+03d'00'", tzonediffWord);
else
- snprintf(tzoneBuf, 15, "%+03d'30'", tzonediffWord);
+ snprintf(tzoneBuf, sizeof(tzoneBuf), "%+03d'30'", tzonediffWord);
/* Get current system time and local time */
GetSystemTime(&SYSTime);
#define NUMT 4
/* List of URLs to fetch.*/
-const char * const urls[]= {
+static const char * const urls[]= {
"https://www.example.com/",
"https://www2.example.com/",
"https://www3.example.com/",
* must be used in real circumstances when a secure connection is required.
*/
+#ifndef OPENSSL_SUPPRESS_DEPRECATED
+#define OPENSSL_SUPPRESS_DEPRECATED
+#endif
+
#include <openssl/ssl.h>
#include <openssl/x509.h>
#include <openssl/pem.h>
RSA *rsa = NULL;
int ret;
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverlength-strings"
+#endif
+
const char *mypem = /* www.cacert.org */
"-----BEGIN CERTIFICATE-----\n"\
"MIIHPTCCBSWgAwIBAgIBADANBgkqhkiG9w0BAQQFADB5MRAwDgYDVQQKEwdSb290\n"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"\
"-----END RSA PRIVATE KEY-----\n";
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
(void)curl; /* avoid warnings */
(void)parm; /* avoid warnings */
curl_easy_cleanup(ch);
curl_global_cleanup();
- return rv;
+ return (int)rv;
}
state->tags++;
state->depth++;
+ (void)name;
+ (void)atts;
+
/* Get a clean slate for reading in character data. */
free(state->characters.memory);
state->characters.memory = NULL;
struct ParserStruct *state = (struct ParserStruct *) userData;
struct MemoryStruct *mem = &state->characters;
- char *ptr = realloc(mem->memory, mem->size + len + 1);
+ char *ptr = realloc(mem->memory, mem->size + (unsigned long)len + 1);
if(!ptr) {
/* Out of memory. */
fprintf(stderr, "Not enough memory (realloc returned NULL).\n");
mem->memory = ptr;
memcpy(&(mem->memory[mem->size]), s, len);
- mem->size += len;
+ mem->size += (unsigned long)len;
mem->memory[mem->size] = 0;
}
struct ParserStruct *state = (struct ParserStruct *) XML_GetUserData(parser);
/* Only parse if we are not already in a failure state. */
- if(state->ok && XML_Parse(parser, contents, real_size, 0) == 0) {
- int error_code = XML_GetErrorCode(parser);
+ if(state->ok && XML_Parse(parser, contents, (int)real_size, 0) == 0) {
+ enum XML_Error error_code = XML_GetErrorCode(parser);
fprintf(stderr, "Parsing response buffer of length %lu failed"
" with error code %d (%s).\n",
real_size, error_code, XML_ErrorString(error_code));
else if(state.ok) {
/* Expat requires one final call to finalize parsing. */
if(XML_Parse(parser, NULL, 0, 1) == 0) {
- int error_code = XML_GetErrorCode(parser);
+ enum XML_Error error_code = XML_GetErrorCode(parser);
fprintf(stderr, "Finalizing parsing failed with error code %d (%s).\n",
error_code, XML_ErrorString(error_code));
}
projects / thirdparty / curl.git / commitdiff
