int http_open(file_source_t* src, file_handle_t* handler, char* filename, int flags){ http_file_handler_t* ofh = (http_file_handler_t*)handler; request_rec* req_r = (request_rec*)src->context; size_t size; int error_code; hls_cache_line_t cl; if (filename[0] == 0) return 0; ap_log_error(APLOG_MARK, APLOG_WARNING, get_log_level(), req_r->server, "HLS file: trying to open HTTP data source %s", filename); strncpy(ofh->link, filename, sizeof(ofh->link)); ofh->r = req_r; ofh->content_length = 0; ofh->last_error_code = 0; ap_log_error(APLOG_MARK, APLOG_WARNING, get_log_level(), req_r->server, "HLS file: trying to read first %d bytes to and cache it", (int)(sizeof(cl.buffer))); http_read(ofh, cl.buffer, sizeof(cl.buffer), 0, flags); ap_log_error(APLOG_MARK, APLOG_WARNING, get_log_level(), req_r->server, "HLS file: got content length %d bytes", (int)ofh->content_length); return ofh->content_length != 0; }
static int8 *get_request_line(struct http_request *req) { if (NULL == req) return NULL; int32 r = 0; int32 i = req->pos; int8 *buf = NULL; int8 ch, *line = NULL; buf = req->buff; again: for (; req->pos < req->sz; req->pos++) { ch = buf[req->pos]; if (ch == '\r') { buf[req->pos] = '\0'; } else if (ch == '\n') { buf[req->pos++] = '\0'; line = &buf[i]; break; } } if ((line == NULL) && (r = http_read(req->fd, buf + req->sz, req->buff_size - req->sz)) > 0) { req->sz += r; get_http_head_sz(req); goto again; } return line; }
static int connection_event(struct connection *c) { int amnt; char buff[BUFF_SZ+1]; buff[BUFF_SZ] = '\0'; amnt = read(c->evt_id, buff, BUFF_SZ); if (0 == amnt) return 1; if (amnt < 0) { printf("read from fd %ld, ret %d\n", c->evt_id, amnt); perror("read from session"); return -1; } buff[amnt] = '\0'; /* The work: */ if (amnt != http_write(c->conn_id, buff, amnt)) { printf("Error writing.\n"); return 1; } while (1) { if ((amnt = http_read(c->conn_id, buff, BUFF_SZ)) < 0) { printf("Error reading (%d)\n", amnt); return -1; } if (0 == amnt) break; if (write(c->evt_id, buff, amnt) != amnt) { perror("writing"); return -1; } } return 0; }
void * conn_handler(void * arr) { int client_fd = *((int*)arr); int keep_alive = 1; while (keep_alive) { http_t req; if (http_read(&req,client_fd) == -1) { http_free(&req); break; } const char * rh = http_get_status(&req); char * uri = process_http_header_request(rh); const char * conn_type = http_get_header(&req, "Connection"); if (conn_type) { if (strcasecmp("keep-alive",conn_type)) keep_alive = 0; //free(conn_type); } else { keep_alive = 0; } char * output = NULL; if (uri) { size_t size; const char * body = http_get_body(&req,&size); jsonreq_t request; request.key = NULL; request.value = NULL; parsereq(body,&request); jsonres_t response = process_request(uri,request); generateres(&output,&response,uri); if (request.key) free(request.key); if (request.value) free(request.value); //if (request) free(request); free(uri); } char * ret_str = ""; asprintf(&ret_str,"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: %zu\r\n\r\n",strlen(output)); send(client_fd,ret_str,strlen(ret_str),0); send(client_fd,output,strlen(output),0); if (output) free(output); if (ret_str) free(ret_str); http_free(&req); } free(arr); close(client_fd); return NULL; }
/* * input */ static enum mad_flow input(void *data, struct mad_stream *stream) { http_t *p = (http_t *) data; static int haveread = 0; /* Clear MAD_BUFFER_GUARD chunk (last 8 bytes): */ memset(buf + MP3_SIZE, 0, MAD_BUFFER_GUARD); int Remaining; char *ReadStart; int ReadSize; /* MAD_ERROR_BUFLEN (= 0x0001) "input buffer too small (or EOF)" */ if (stream->error == MAD_ERROR_BUFLEN) { /* Some data not decoded; must reissue: */ Remaining = stream->bufend - stream->next_frame; memcpy(buf, stream->next_frame, Remaining); ReadStart = buf + Remaining; ReadSize = MP3_SIZE - Remaining; } else { ReadStart = buf; ReadSize = MP3_SIZE; Remaining = 0; } int got = http_read(p, ReadStart, ReadSize); if (got == 0) { /* Reset: */ buf = buf1; haveread = 0; next_item(); return MAD_FLOW_STOP; } haveread += got; mad_stream_buffer(stream, buf, Remaining + got); /* Switch between buffers: */ if (buf == buf1) { buf = buf2; } else { buf = buf1; } return MAD_FLOW_CONTINUE; }
static int http_seek_to_end(void *appdata) { assert(appdata); netfile* nf = (netfile*) appdata; int n = 0; do { Uint8 b; n = http_read(&b, 1, appdata); } while (n == 1); return 0; }
char *System::loadResource(const char *fileName) { char *buffer = NULL; if (strstr(fileName, "://") != NULL) { String *cached = _cache.get(fileName); if (cached != NULL) { int len = cached->length(); buffer = (char *)malloc(len + 1); memcpy(buffer, cached->c_str(), len); buffer[len] = '\0'; } else { int handle = 1; var_t *var_p = v_new(); dev_file_t *f = dev_getfileptr(handle); _output->setStatus("Loading..."); _output->redraw(); if (dev_fopen(handle, fileName, 0)) { if (http_read(f, var_p) == 0) { systemPrint("\nfailed to read %s\n", fileName); } else { int len = var_p->v.p.length; buffer = (char *)malloc(len + 1); memcpy(buffer, var_p->v.p.ptr, len); buffer[len] = '\0'; _cache.add(fileName, buffer); } } else { systemPrint("\nfailed to open %s\n", fileName); } _output->setStatus(NULL); dev_fclose(handle); v_free(var_p); v_detach(var_p); opt_file_permitted = 0; } } if (buffer == NULL) { // remove failed item from history strlib::String *old = _history.peek(); if (old && old->equals(fileName)) { delete _history.pop(); } } return buffer; }
static void httptr_io_cb(int sd, short type, void *arg) { struct tr_response res; struct httptr_req *treq = arg; switch (type) { case EV_READ: if (http_read(treq->req, sd) && !http_want_read(treq->req)) btpd_ev_disable(&treq->ioev, EV_READ); break; case EV_WRITE: if (http_write(treq->req, sd) && !http_want_write(treq->req)) btpd_ev_disable(&treq->ioev, EV_WRITE); break; case EV_TIMEOUT: res.type = TR_RES_CONN; tr_result(treq->tr, &res); httptr_cancel(treq); break; default: abort(); } }
void *http_process(void *args) { int32 fd; struct http_request *req; int8 *cp = NULL; int8 *line = NULL; int8 *method = NULL; int8 *url = NULL; int8 *protocol = NULL; struct timeval timo; int32 optval = 1; int32 rc, rc_r, rc_s; int32 r = 0; if (NULL == args) return NULL; req = (struct http_request *)args; fd = req->fd; req->buff = malloc(BUFFSIZ); req->buff_size = BUFFSIZ; if (NULL == req->buff) { HTTPD_ERR("get_request_line malloc %d fail\n", BUFFSIZ); free(args); return NULL; } memset(req->buff, 0, BUFFSIZ); rc = setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval)); if (rc < 0) HTTPD_ERR("setsockopt error rc=%d errno=%d %s\n", rc, errno, strerror(errno)); timo.tv_sec = HTTPD_TIMO; timo.tv_usec = 0; rc_r = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timo, sizeof(timo)); rc_s = setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timo, sizeof(timo)); if (rc_r < 0 || rc_s < 0) HTTPD_ERR("setsockopt error fd=%d rc=%d rc_r=%d rc_s=%d errno=%d %s\n", fd, rc, rc_r, rc_s, errno, strerror(errno)); /* GET / HTTP/1.1 */ method = get_request_line(req); if (method == NULL) goto close_task; url = parse_reqline(fd, method); if (url == NULL) goto close_task; protocol = parse_reqline(fd, url); if (protocol == NULL) goto close_task; req->method = http_method(method); if (req->method == M_OPTIONS) { send_error(fd, 204, "No Content", NULL, "Method OPTIONS."); goto close_task; } if (req->method == M_UNKNOWN) { send_error(fd, 400, "Bad Request", NULL, "Method Not Support."); goto close_task; } decode_url(req, url); HTTPD_INFO("method[%s] protocol[%s] url[%s] path[%s] query[%s]!\n", method, protocol, url, req->path, req->query ? : ""); while ((line = get_request_line(req)) != NULL) { if (line[0] == '\0') break; if (strncasecmp(line, "Upgrade:", 8) == 0) { cp = &line[8]; cp += strspn(cp, " \t"); if (strncasecmp(cp, "websocket", 9) == 0) req->is_websocket = 1; } else if (strncasecmp(line, "Connection:", 11) == 0) { cp = &line[11]; cp += strspn(cp, " \t"); /* Firefox: [Connection: keep-alive, Upgrade] */ if (strcasestr(cp, "Upgrade") != NULL) req->is_connection_upgrade = 1; } else if (strncasecmp(line, "Sec-WebSocket-Key:", 18) == 0) { cp = &line[18]; cp += strspn(cp, " \t"); req->sec_websocket_key = cp; } else if (strncasecmp(line, "Origin:", 7) == 0) { cp = &line[7]; cp += strspn(cp, " \t"); req->origin = cp; } else if (strncasecmp(line, "Sec-WebSocket-Version:", 22) == 0) { cp = &line[22]; cp += strspn(cp, " \t"); req->sec_websocket_version = atoi(cp); } else if (strncasecmp(line, "Content-Length:", 15) == 0) { cp = &line[15]; cp += strspn(cp, " \t"); req->content_length = atol(cp); if ((BUFFSIZ < req->content_length + MAX_HEADER_LEN) && (req->buff_size != req->content_length + MAX_HEADER_LEN) + 1) { re_alloc_buff(req); memset(req->buff + BUFFSIZ, 0, req->buff_size - BUFFSIZ); } } else if (strncasecmp(line, "Content-Type:", 13) == 0) { cp = &line[13]; cp += strspn(cp, " \t"); req->content_type = cp; } else if (strncasecmp(line, "Host:", 5) == 0) { cp = &line[5]; cp += strspn(cp, " \t"); req->host = cp; } } HTTPD_INFO("Left %d bytes HTTP data with Content-Length: %ld req->sz[%d] req->pos[%d]\n", req->sz - req->pos, req->content_length, req->sz, req->pos); if (line == NULL || req->path[0] != '/') send_error(fd, 400, "Bad Request", NULL, "Bad Request!"); if ((0 != req->content_length) && (req->sz != req->hd_sz + req->content_length)) { while ((r = http_read(req->fd, req->buff + req->sz, req->buff_size - req->sz)) > 0) { req->sz += r; if (req->sz == req->hd_sz + req->content_length) break; } } if (req->is_websocket) ws_process(req); else { uint32 i = 0; int8 *file = NULL; int8 *path = req->path; int8 *pTmp = path; int8 prefix[PREFIX_LEN] = {0}; int8 new_link[MAX_URL + 8] = {0}; rmm_cfg_get_rest_prefix(prefix, PREFIX_LEN); /*snprintf(new_link, (MAX_URL + 8), "%s%s", prefix, "/rack");*/ snprintf_s_s(new_link, (MAX_URL + 8), "%s", prefix); /*TODO: move to correct place */ get_json_pointer(req); /* remove redundant '/' */ for (; *(path+i) != '\0'; i++) { if ((*(path+i) == '/') && (*(path+i+1) == '/')) continue; *pTmp++ = *(path+i); } *pTmp = '\0'; if ((path[1] == '\0') || (strncasecmp(path, new_link, strnlen_s(new_link, sizeof(new_link)-1)) == 0)) file = NULL; else file = path; if (file != NULL) send_file(req->fd, file); else rest_process(req); } close_task: close(fd); if (NULL != req->buff) { free(req->buff); req->buff = NULL; } HTTPD_INFO("\nrest_req_thread[%lld] exit, fd[%d], errno:%d %s\n", (uint64)(req->tid_rest_req), fd, errno, strerror(errno)); free(args); pthread_detach(pthread_self()); return NULL; }
void *check_version_proc(void *ptr) { int patch, build; char *url = "http://gridlab-d.svn.sourceforge.net/viewvc/gridlab-d/trunk/core/versions.txt"; HTTPRESULT *result = http_read(url,0x1000); char target[32]; char *pv = NULL, *nv = NULL; int rc = 0; int mypatch = REV_PATCH; int mybuild = atoi(BUILDNUM); /* if result not found */ if ( result==NULL || result->body.size==0 ) { output_warning("check_version: unable to read %s", url); rc=CV_NOINFO; goto Done; } /** @todo check the version against latest available **/ if ( result->status>0 && result->status<400 ) { output_warning("check_version: '%s' error %d", url, result->status); rc=CV_BADURL; goto Done; } /* read version data */ sprintf(target,"%d.%d:",REV_MAJOR,REV_MINOR); pv = strstr(result->body.data,target); if ( pv==NULL ) { output_warning("check_version: '%s' has no entry for version %d.%d", url, REV_MAJOR, REV_MINOR); rc=CV_NODATA; goto Done; } if ( sscanf(pv,"%*d.%*d:%d:%d", &patch, &build)!=2 ) { output_warning("check_version: '%s' entry for version %d.%d is bad", url, REV_MAJOR, REV_MINOR); rc=CV_NODATA; goto Done; } nv = strchr(pv,'\n'); if ( nv!=NULL ) { while ( *nv!='\0' && isspace(*nv) ) nv++; if ( *nv!='\0' ) { output_warning("check_version: newer versions than %s (Version %d.%d) are available", BRANCH, REV_MAJOR, REV_MINOR); rc|=CV_NEWVER; } /* not done yet */ } if ( mypatch<patch ) { output_warning("check_version: a newer patch of %s (Version %d.%d.%d-%d) is available", BRANCH, REV_MAJOR, REV_MINOR, patch, build); rc|=CV_NEWPATCH; /* not done yet */ } if ( mybuild>0 && mybuild<build ) { output_warning("check_version: a newer build of %s (Version %d.%d.%d-%d) is available", BRANCH, REV_MAJOR, REV_MINOR, patch, build); rc|=CV_NEWBUILD; } if ( rc==0 ) output_verbose("this version is current"); /* done */ Done: http_delete_result(result); return (void*)rc; }
static int read_http_payload(struct ledm_session *ps, char *payload, int max_size, int sec_timeout, int *bytes_read) { struct bb_ledm_session *pbb = ps->bb_session; int stat=1, total=0, len; int tmo=sec_timeout; enum HTTP_RESULT ret; int payload_length=-1; char *temp=NULL; *bytes_read = 0; if(http_read_header(pbb->http_handle, payload, max_size, tmo, &len) != HTTP_R_OK) goto bugout; _DBG("read_http_payload len=%d %s\n",len,payload); temp = strstr(payload, "HTTP/1.1 201 Created"); if (temp) { *bytes_read = total = len; stat=0; return stat ; } temp=strstr(payload, "Content-Length:"); if (temp) { temp=temp+16; temp=strtok(temp, "\r\n"); payload_length=strtol(temp, NULL, 10); if (payload_length == 0) { *bytes_read = total = len; stat=0; return stat ; } } memset(payload, ' ', len); if(payload_length==-1) { int i=10; while(i) { len = 0; ret = http_read(pbb->http_handle, payload+total, max_size-total, tmo, &len); total+=len; tmo=1; i--; if (ret == HTTP_R_EOF) { _DBG("read_http_payload1 DONE......\n"); break; /* done */ } if (!(ret == HTTP_R_OK || ret == HTTP_R_EOF)) { _DBG("read_http_payload1 ERROR......\n"); goto bugout; } }//end while(i) }//end if(payload_length==-1) else { len=payload_length; while (total < payload_length) { ret = http_read(pbb->http_handle, payload+total, max_size-total, tmo, &len); total+=len; tmo=1; if (ret == HTTP_R_EOF) { _DBG("read_http_payload2 DONE......\n"); break; /* done */ } if (!(ret == HTTP_R_OK || ret == HTTP_R_EOF)) { _DBG("read_http_payload2 ERROR......\n"); goto bugout; } }//end while() }//end else *bytes_read = total; stat=0; bugout: return stat; } /* read_http_payload */
UNSIGNED32 get_timestamp_response(const char* urlStr, char* hash, UNSIGNED32 hash_size, UNSIGNED32 httpTimeOut, TS_RESP** tsResponse) { UNSIGNED32 result = TINTERNALERROR; BIO* responseBio = NULL; Url* url = NULL; TS_REQ* tsRequest = NULL; BIO* requestBio = NULL; int requestHeaderLength; int requestLength; int requestContentLength; char requestHeader[2048 + 256]; char* request = NULL; void* contentBuffer = NULL; void* resultBuffer = NULL; int resultLength; TS_MSG_IMPRINT* msgImprint = NULL; ASN1_OCTET_STRING* hashedMessage = NULL; int hashedMessageLength; int httpResult; char *urlBuffer = NULL; int redirection = 0; /* Check if TS url is specified */ if (!urlStr) { goto end; } /* Get Request for timestamp */ tsRequest = get_timestamp_request(hash, hash_size, create_nonce(NONCE_LENGTH)); msgImprint = TS_REQ_get_msg_imprint(tsRequest); hashedMessage = TS_MSG_IMPRINT_get_msg(msgImprint); hashedMessageLength = ASN1_STRING_length((ASN1_STRING*)hashedMessage); if ((int)hash_size != hashedMessageLength) { goto end; } requestBio = BIO_new(BIO_s_mem()); if (requestBio == NULL) { goto end; } if (!i2d_TS_REQ_bio(requestBio, tsRequest)) { goto end; } contentBuffer = memory_alloc(BIO_number_written(requestBio)); if (contentBuffer == NULL) { goto end; } requestContentLength = BIO_read(requestBio, contentBuffer, BIO_number_written(requestBio)); /* Allocate memory buffer for timestamp server url */ urlBuffer = memory_alloc(strlen(urlStr) + 1); if (!urlBuffer) { goto end; } /* Copy TS url to allocated buffer */ strcpy(urlBuffer, urlStr); http_redirect: /* Parse and check URL */ url = parse_url(urlBuffer); if (url == NULL) { goto end; } if (strcmp(url->Scheme, "http") != 0) { goto end; } requestHeaderLength = sprintf(requestHeader, "POST %s HTTP/1.0\r\nHOST: %s\r\nPragma: no-cache\r\nContent-Type: application/timestamp-query\r\nAccept: application/timestamp-reply\r\nContent-Length: %d\r\n\r\n", urlBuffer, url->Host, requestContentLength); requestLength = requestHeaderLength + requestContentLength; request = (char*)memory_alloc(requestLength); if (request == NULL) { goto end; } memcpy(request, requestHeader, requestHeaderLength); memcpy(request + requestHeaderLength, contentBuffer, requestContentLength); httpResult = http_read(url->Host, request, requestLength, url->Port, httpTimeOut, 1, &resultBuffer, &resultLength); if (httpResult == HTTP_REDIRECTION && (resultBuffer) && !redirection) { free_url(url); url = NULL; memory_free(request); request = NULL; /* Allocated buffer for redirected url */ urlBuffer = memory_realloc(urlBuffer, resultLength); if (!urlBuffer) { goto end; } memcpy(urlBuffer, resultBuffer, resultLength); memory_free(resultBuffer); redirection++; goto http_redirect; } else if ((httpResult == HTTP_NOERROR) && (resultBuffer)) { responseBio = BIO_new(BIO_s_mem()); if (responseBio == NULL) { goto end; } BIO_write(responseBio, resultBuffer, resultLength); *tsResponse = d2i_TS_RESP_bio(responseBio, NULL); if (*tsResponse == NULL) { goto end; } result = TNOERR; } else { switch (httpResult) { case HTTP_NOLIVEINTERNET_ERROR: result = TNONET; break; case HTTP_TIMEOUT_ERROR: result = TTIMEOUT; break; case HTTP_RESPONSESTATUS_ERROR: result = TSERVERERROR; break; default: result = TINTERNALERROR; break; } } end: free_url(url); if (tsRequest != NULL) { TS_REQ_free(tsRequest); } if (requestBio != NULL) { BIO_free_all(requestBio); } if (responseBio != NULL) { BIO_free_all(responseBio); } if (request != NULL) { memory_free(request); } if (contentBuffer != NULL) { memory_free(contentBuffer); } if (resultBuffer != NULL) { memory_free(resultBuffer); } if (urlBuffer != NULL) { memory_free(urlBuffer); } return result; }
void http_buf(TCP_NODE * n) { char *p_cmd = NULL; char *p_url = NULL; char *p_var = NULL; char *p_proto = NULL; char *p_head = NULL; char *p_body = NULL; HASH *head = NULL; char recv_buf[BUF_SIZE]; /* Do not start before at least this much arrived: "GET / HTTP/1.1" */ if (n->recv_size <= 14) { return; } /* Copy HTTP request */ memset(recv_buf, '\0', BUF_SIZE); memcpy(recv_buf, n->recv_buf, n->recv_size); /* Return until the header is complete. Gets killed if this grows beyond * all imaginations. */ if ((p_body = strstr(recv_buf, "\r\n\r\n")) == NULL) { return; } /* Keep one \r\n for consistent header analysis. */ *p_body = '\r'; p_body++; *p_body = '\n'; p_body++; *p_body = '\0'; p_body++; *p_body = '\0'; p_body++; /* HTTP Pipelining: There is at least one more request. */ if (n->recv_size > (ssize_t) (p_body - recv_buf)) { n->recv_size -= (ssize_t) (p_body - recv_buf); memset(n->recv_buf, '\0', BUF_SIZE); memcpy(n->recv_buf, p_body, n->recv_size); } else { /* The request has been copied. Reset the receive buffer. */ node_clearRecvBuf(n); } /* Remember start point */ p_cmd = recv_buf; /* Find url */ if ((p_url = strchr(p_cmd, ' ')) == NULL) { info(_log, &n->c_addr, "Requested URL was not found"); node_status(n, NODE_SHUTDOWN); return; } *p_url = '\0'; p_url++; /* Find protocol type */ if ((p_proto = strchr(p_url, ' ')) == NULL) { info(_log, &n->c_addr, "No protocol found in request"); node_status(n, NODE_SHUTDOWN); return; } *p_proto = '\0'; p_proto++; /* Find variables( Start from p_url again) */ if ((p_var = strchr(p_url, '?')) != NULL) { *p_var = '\0'; p_var++; } /* Find header lines */ if ((p_head = strstr(p_proto, "\r\n")) == NULL) { info(_log, &n->c_addr, "There must be a \\r\\n. I put it there..."); node_status(n, NODE_SHUTDOWN); return; } *p_head = '\0'; p_head++; *p_head = '\0'; p_head++; /* Hash header */ head = http_hashHeader(p_head); /* Validate input */ http_read(n, p_cmd, p_url, p_proto, head); /* Delete Hash */ http_deleteHeader(head); }
/*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ ascp $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/ int main(int argc, char *argv[]) { int bytes_buffered, fd, hunk_size; off_t bytes_read = 0; char block[1024], hostname[45], path[MAX_PATH_LENGTH]; if ((argc != 2) && (argc != 3) && (argc != 4)) { (void)fprintf(stderr, "Usage: %s <filename> [<host> [<path>]]\n", argv[0]); exit(-1); } if (argc == 4) { (void)strncpy(hostname, argv[2], 44); (void)strncpy(path, argv[3], MAX_PATH_LENGTH - 1); } else if (argc == 3) { (void)strncpy(hostname, argv[2], 44); (void)strcpy(path, "/"); } else { (void)strcpy(hostname, "localhost"); (void)strcpy(path, "/"); } if (http_connect(hostname, DEFAULT_HTTP_PORT) == -1) { (void)fprintf(stderr, "http_connect() failed\n"); exit(-1); } if (http_get(hostname, path, argv[1], &bytes_buffered) == INCORRECT) { (void)fprintf(stderr, "http_get() failed\n"); exit(-1); } if ((fd = open(argv[1], (O_WRONLY | O_CREAT | O_TRUNC), (S_IRUSR | S_IWUSR))) == -1) { (void)fprintf(stderr, "Failed to open() %s : %s\n", argv[1], strerror(errno)); exit(-1); } if (bytes_buffered > 0) { bytes_read += bytes_buffered; if (write(fd, msg_str, bytes_buffered) != bytes_buffered) { (void)fprintf(stderr, "write() error : %s\n", strerror(errno)); exit(-1); } } while ((hunk_size = http_read(block, 1024)) > 0) { if (write(fd, block, hunk_size) != hunk_size) { (void)fprintf(stderr, "write() error : %s\n", strerror(errno)); exit(-1); } bytes_read += hunk_size; } if (close(fd) == -1) { (void)fprintf(stderr, "close() error : %s\n", strerror(errno)); } (void)fprintf(stdout, "Got file %s with %d Bytes.\n", argv[1], bytes_read); return(0); }