int send_request(Request req) { if (! req->socket ) { req->socket = connect_socket(req->host,req->port,0); if (! req->socket) { error("Failed to connect to %s:%i\n",req->host,req->port); return 0; } add_req_socket(req->socket->fd); return 0; } if (req->length < 0) { str cmd = _("%s %s HTTP/1.1\r\n",req->method,req->path); write_socket(req->socket,cmd); request_headers(req,_("Host"),req->host); send_headers(req->socket,req->headers); req->length = outbound_content_length(req->contents,req->raw_contents); return req->contents != NULL || req->raw_contents != NULL ; } req->written += req->contents ? send_contents(req->socket,req->contents,is_chunked(req->headers)) : req->raw_contents ? send_raw_contents(req->socket,req->raw_contents,req->written,0): 0; if (is_chunked(req->headers) && req->written >= req->length) write_chunk(req->socket,NULL,0); return req->written < req->length; }
/** * Encodes the strings and writes the encoded data to file. * @param out File to write to * @param head Head of list of strings to encode & write * @param label_prefix */ static void write_huffman_strings(FILE *out, const string_list_t *head, const char *label_prefix) { const string_list_t *string; int string_id = 0; for (string = head; string != NULL; string = string->next) { char strlabel[256]; char strcomment[80]; sprintf(strlabel, "%sString%d", label_prefix, string_id++); strcpy(strcomment, "\""); if (strlen((char *)string->text) < 40) { strcat(strcomment, (char *)string->text); } else { strncat(strcomment, (char *)string->text, 37); strcat(strcomment, "..."); } strcat(strcomment, "\""); /* Write encoded data */ write_chunk(out, strlabel, strcomment, string->huff_data, string->huff_size, 16); } }
void create_mgif_delta() { void *d; long siz; //conv_2_rgb(); init_palmap(); if (BZTRATA) create_color_state(); set_max_color_change(BZTRATA); create_low_quality(); if (delta_data_size+frame_delta_size>FRAME_LEN) { create_mgif_lzw(); return; } if (!frame_delta_size) return; reduce_palette(); filter_colors(frame_delta,frame_delta_size,color_map); d=join_two_blocks(delta_data,frame_delta,delta_data_size,frame_delta_size,&siz); init_lzw_compressor(8); memset(lzw_buffer,0,sizeof(lzw_buffer)); siz=lzw_encode(d,lzw_buffer,siz); done_lzw_compressor(); free(d); if (siz>FRAME_LEN) { create_mgif_lzw(); return; } write_chunk(MGIF_DELTA,siz,lzw_buffer); create_mgif_pal(); }
VOID png_write(struct RecorderData *data, APTR fh, APTR argb, ULONG modulo, ULONG width, ULONG height, ULONG dupcount) { struct png_header ihdr; ULONG length, length2; UBYTE *buffer; buffer = data->writebuffer; ihdr.width = width; ihdr.height = height; ihdr.depth = 8; ihdr.colortype = 2; /* RGB */ ihdr.compression = 0; ihdr.filter = 0; ihdr.interlaced = 0; length = write_chunk(buffer, sizeof(ihdr), LE_SWAPLONG_C(MAKE_ID('I','H','D','R')), &ihdr); length2 = png_encode(&buffer[length], data->writebuffersize - length - 8, argb, modulo, width, height); if (length2) { static const struct png_iend iend = { { 0, LE_SWAPLONG_C(MAKE_ID('I','E','N','D')) }, 0xae426082 }; ULONG i; length += length2; qcopy((APTR)&iend, &buffer[length], sizeof(iend)); for (i = 0; i < dupcount; i++) { dowrite(fh, buffer, length); } } }
void create_mgif_lzw() { int siz; //conv_2_rgb(); init_palmap(); create_mgif_pal(); filter_colors(frame_buffer,FRAME_LEN,color_map); create_last_frame(frame_buffer,last_frame,hipal,FRAME_LEN); init_lzw_compressor(8); memset(lzw_buffer,0,sizeof(lzw_buffer)); siz=lzw_encode(frame_buffer,lzw_buffer,FRAME_LEN); if (siz>FRAME_LEN) write_chunk(MGIF_COPY,FRAME_LEN,frame_buffer); else write_chunk(MGIF_LZW,siz,lzw_buffer); done_lzw_compressor(8); }
/* Shuffle large input stream by splitting into chunks */ int shuffle_by_chunks() { long i = 0, l = 0; int fidcounter = 0; char filename[MAX_STRING_LENGTH]; CREC *array; FILE *fin = stdin, *fid; array = malloc(sizeof(CREC) * array_size); fprintf(stderr,"SHUFFLING COOCCURRENCES\n"); if(verbose > 0) fprintf(stderr,"array size: %lld\n", array_size); sprintf(filename,"%s_%04d.bin",file_head, fidcounter); fid = fopen(filename,"w"); if(fid == NULL) { fprintf(stderr, "Unable to open file %s.\n",filename); return 1; } if(verbose > 1) fprintf(stderr, "Shuffling by chunks: processed 0 lines."); while(1) { //Continue until EOF if(i >= array_size) {// If array is full, shuffle it and save to temporary file shuffle(array, i-2); l += i; if(verbose > 1) fprintf(stderr, "\033[22Gprocessed %ld lines.", l); write_chunk(array,i,fid); fclose(fid); fidcounter++; sprintf(filename,"%s_%04d.bin",file_head, fidcounter); fid = fopen(filename,"w"); if(fid == NULL) { fprintf(stderr, "Unable to open file %s.\n",filename); return 1; } i = 0; } fread(&array[i], sizeof(CREC), 1, fin); if(feof(fin)) break; i++; } shuffle(array, i-1); //Last chunk may be smaller than array_size write_chunk(array,i,fid); l += i; if(verbose > 1) fprintf(stderr, "\033[22Gprocessed %ld lines.\n", l); if(verbose > 1) fprintf(stderr, "Wrote %d temporary file(s).\n", fidcounter + 1); fclose(fid); free(array); return shuffle_merge(fidcounter + 1); // Merge and shuffle together temporary files }
int main (int argc, char const *argv[]) { UNUSED_ARG(argc); UNUSED_ARG(argv); unsigned i; memory_pool * mp = mempool_new(POOL_ENTRIES, POOL_ENTRY_SIZE); void * chunks[POOL_ENTRIES]; // Allocate all then free all for(i = 0; i < POOL_ENTRIES; ++i) { //Allocate chunk chunks[i] = mempool_alloc(mp); //Write into it write_chunk(chunks[i], (char)(i % 255)); } for(i = 0; i < POOL_ENTRIES; ++i) { //Verify contents verify_chunk(chunks[i], (char)(i % 255)); //Release mempool_free(mp, chunks[i]); chunks[i] = NULL; } // Allocate all then free by using is_mempool_exhaused for(i = 0; is_mempool_exhaused(mp) == false; ++i) { //Allocate chunk chunks[i] = mempool_alloc(mp); //Write into it write_chunk(chunks[i], (char)(i % 255)); } assert(i == POOL_ENTRIES); for(i = 0; i < POOL_ENTRIES; ++i) { //Verify contents verify_chunk(chunks[i], (char)(i % 255)); //Release mempool_free(mp, chunks[i]); chunks[i] = NULL; } printf("TEST SUCCESSFUL!\n"); return 0; }
void create_sound_track(int size) { void *p; p=getmem(size); memset(p,0,size); write_chunk(MGIF_SOUND,size,p); free(p); }
void RtmpMessageContext::to_chunk( RtmpMessageHeader const & msg, RtmpChunkHeader & chunk) { RtmpChunkHeader & wchunk(write_chunk(msg.chunk)); chunk.calc_timestamp = msg.timestamp; chunk.message_length = msg.length; chunk.message_type_id = msg.type; chunk.message_stream_id = msg.stream; chunk = wchunk.dec(chunk); }
static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias) { __u8 bytes[chunkSize]; yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)bytes; memset(bytes,0xff,sizeof(bytes)); oh->type = t; oh->parentObjectId = parent; strncpy(oh->name,name,YAFFS_MAX_NAME_LENGTH); if(t != YAFFS_OBJECT_TYPE_HARDLINK) { oh->yst_mode = s->st_mode; oh->yst_uid = s->st_uid; // NCB 12/9/02 oh->yst_gid = s->yst_uid; oh->yst_gid = s->st_gid; oh->yst_atime = s->st_atime; oh->yst_mtime = s->st_mtime; oh->yst_ctime = s->st_ctime; oh->yst_rdev = s->st_rdev; } if(t == YAFFS_OBJECT_TYPE_FILE) { oh->fileSize = s->st_size; } if(t == YAFFS_OBJECT_TYPE_HARDLINK) { oh->equivalentObjectId = equivalentObj; } if(t == YAFFS_OBJECT_TYPE_SYMLINK) { strncpy(oh->alias,alias,YAFFS_MAX_ALIAS_LENGTH); } if (convert_endian) { object_header_little_to_big_endian(oh); } return write_chunk(bytes,objId,0,0xffff); }
/* * Write a big chunk with 'progress' indicator '.' for every MiB */ static int write_big_chunk(int fd, void *addr, size_t count) { unsigned char *a = addr; size_t total = 0; if (count < 0x100000) return write_chunk(fd, addr, count); /* if large chunk then print dot to show progress */ while (total < count) { size_t bytes = count - total; kick_mpcore_wdt(); if (bytes > 0x100000) bytes = 0x100000; if (write_chunk(fd, a, bytes)) return -1; putc('.'); total += bytes; a += bytes; } putc('\n'); return 0; }
/* Merge shuffled temporary files; doesn't necessarily produce a perfect shuffle, but good enough */ int shuffle_merge(int num) { long i, j, k, l = 0; int fidcounter = 0; CREC *array; char filename[MAX_STRING_LENGTH]; FILE **fid, *fout = stdout; array = malloc(sizeof(CREC) * array_size); fid = malloc(sizeof(FILE) * num); for(fidcounter = 0; fidcounter < num; fidcounter++) { //num = number of temporary files to merge sprintf(filename,"%s_%04d.bin",file_head, fidcounter); fid[fidcounter] = fopen(filename, "rb"); if(fid[fidcounter] == NULL) { fprintf(stderr, "Unable to open file %s.\n",filename); return 1; } } if(verbose > 0) fprintf(stderr, "Merging temp files: processed %ld lines.", l); while(1) { //Loop until EOF in all files i = 0; //Read at most array_size values into array, roughly array_size/num from each temp file for(j = 0; j < num; j++) { if(feof(fid[j])) continue; for(k = 0; k < array_size / num; k++){ fread(&array[i], sizeof(CREC), 1, fid[j]); if(feof(fid[j])) break; i++; } } if(i == 0) break; l += i; shuffle(array, i-1); // Shuffles lines between temp files write_chunk(array,i,fout); if(verbose > 0) fprintf(stderr, "\033[31G%ld lines.", l); } fprintf(stderr, "\033[0GMerging temp files: processed %ld lines.", l); for(fidcounter = 0; fidcounter < num; fidcounter++) { fclose(fid[fidcounter]); sprintf(filename,"%s_%04d.bin",file_head, fidcounter); remove(filename); } fprintf(stderr, "\n\n"); free(array); return 0; }
static void write_share_chunk(struct buffer *buffer, struct share *share) { struct buffer sharebuf = { .bytes = share->chunk, .len = share->chunk_len, .max = share->chunk_len }; write_chunk(buffer, &sharebuf, "SHAR"); } size_t blob_write(const struct blob *blob, const unsigned char key[KDF_HASH_LEN], char **out) { struct buffer buffer; struct share *last_share = NULL; _cleanup_free_ char *version; memset(&buffer, 0, sizeof(buffer)); version = xultostr(blob->version); buffer_append(&buffer, "LPAV", 4); write_plain_string(&buffer, version); buffer_append(&buffer, "LOCL", 4); write_plain_string(&buffer, LASTPASS_CLI_VERSION); for (struct account *account = blob->account_head; account; account = account->next) { if (!account->share) write_account_chunk(&buffer, account, key); } for (struct account *account = blob->account_head; account; account = account->next) { if (!account->share) continue; if (last_share != account->share) { write_share_chunk(&buffer, account->share); last_share = account->share; } write_account_chunk(&buffer, account, account->share->key); } *out = buffer.bytes; return buffer.len; } static struct blob *local_blob(const unsigned char key[KDF_HASH_LEN], const struct private_key *private_key) { _cleanup_free_ char *blob = NULL; size_t len = config_read_encrypted_buffer("blob", &blob, key); if (!blob) return NULL; return blob_parse(blob, len, key, private_key); }
}static int inflate_into_chunk(struct mem_chunk m) {unsigned cont_size,decompressed;const char*cont;z_stream str;int err; unsigned orig_size;MemSet(&str,sizeof str,0);decompressed=0; orig_size=*((const unsigned*)*indices);cont=*indices+sizeof(orig_size); cont_size=MemPtrSize(*indices)-2;decompressed=0; str.next_in=(char*)cont;str.avail_in=cont_size; err=inflateInit(&str); if(err){zlib_error_alert(err,"inflateInit");return err;} while(decompressed<orig_size) {unsigned n;str.next_out=zlib_buf;str.avail_out=zlib_buf_size; err=inflate(&str,0); if(err&&err!=Z_STREAM_END) {zlib_error_alert(err,"inflate");inflateEnd(&str);return err;} n=zlib_buf_size-str.avail_out; write_chunk(m,decompressed,zlib_buf,n);decompressed+=n; }while(err!=Z_STREAM_END); err=inflateEnd(&str);if(err)zlib_error_alert(err,"inflateEnd");return err; }static const char*saved_uncompressed;
void gen_handler(struct evhttp_request *req, void *arg) { DBG(); /*struct evbuffer *evb = evbuffer_new(); */ const char *uri = evhttp_request_get_uri(req); struct evhttp_uri *decoded_uri = NULL; const char *path; char *decoded_path; /* Decode the URI */ decoded_uri = evhttp_uri_parse(uri); if (!decoded_uri) { reply_error(req, HTTP_BADREQUEST, "Bad URI: %s", uri); return; } path = evhttp_uri_get_path(decoded_uri); if (!path) { logging(LOG_INFO, "request path is nil, replace it as /"); path = "/"; } decoded_path = evhttp_uridecode(path, 0, NULL); uint64_t chunkid; char *slash = strchr(path + 1, '/'); *slash = '\0'; const char *op = path + 1; sscanf(slash + 1, "%" SCNu64, &chunkid); logging(LOG_INFO, "%s, %" PRIu64, op, chunkid); if (strcmp(op, "put") == 0) { write_chunk(chunkid, req); } else if (strcmp(op, "get") == 0) { read_chunk(chunkid, req); } else { reply_error(req, HTTP_NOTFOUND, "not found: %s", uri); return; } }
int write (int fd, char *buf, int len) { int rv = 0; int c; #if 0 if (fd == 2) fprintf (stderr, "%.*s", buf, len); else if (fd == 1) printf ("%.*s", buf, len); #endif while (len > 0) { int l = (len > CIO_BUF_SIZE) ? CIO_BUF_SIZE : len; c = write_chunk (fd, buf, l); if (c < 0) return c; rv += l; len -= l; buf += l; } return rv; }
static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias, const char *secontext) { __u8 bytes[chunkSize]; yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)bytes; char *xb = (char *)bytes + sizeof(*oh); int xnamelen = strlen(XATTR_NAME_SELINUX) + 1; int xvalsize = 0; int xreclen = 0; if (secontext) { xvalsize = strlen(secontext) + 1; xreclen = sizeof(int) + xnamelen + xvalsize; } memset(bytes,0xff,sizeof(bytes)); oh->type = t; oh->parentObjectId = parent; strncpy(oh->name,name,YAFFS_MAX_NAME_LENGTH); if (xreclen) { memcpy(xb, &xreclen, sizeof(int)); xb += sizeof(int); strcpy(xb, XATTR_NAME_SELINUX); xb += xnamelen; memcpy(xb, secontext, xvalsize); } if(t != YAFFS_OBJECT_TYPE_HARDLINK) { oh->yst_mode = s->st_mode; oh->yst_uid = s->st_uid; // NCB 12/9/02 oh->yst_gid = s->yst_uid; oh->yst_gid = s->st_gid; oh->yst_atime = s->st_atime; oh->yst_mtime = s->st_mtime; oh->yst_ctime = s->st_ctime; oh->yst_rdev = s->st_rdev; } if(t == YAFFS_OBJECT_TYPE_FILE) { oh->fileSize = s->st_size; } if(t == YAFFS_OBJECT_TYPE_HARDLINK) { oh->equivalentObjectId = equivalentObj; } if(t == YAFFS_OBJECT_TYPE_SYMLINK) { strncpy(oh->alias,alias,YAFFS_MAX_ALIAS_LENGTH); } if (convert_endian) { object_header_little_to_big_endian(oh); } return write_chunk(bytes,objId,0,0xffff); }
int end_response() { write_chunk(client.response->socket,NULL,0); return 0; }
/* * Dump crash to file */ static int write_elf(Elf32_Ehdr *elfhdr_addr, int fd) { Elf32_Ehdr *oldhdr = elfhdr_addr; Elf32_Ehdr *ehdr; Elf32_Phdr *phdr; u32 i; u32 offset; u32 tot; u32 phdr_cnt; u32 notes_cnt = 0; u32 save; u32 len; offset = oldhdr->e_ehsize + oldhdr->e_phentsize * oldhdr->e_phnum; ehdr = (Elf32_Ehdr *) malloc(offset); if (ehdr == NULL) { debug("elf header alloc error\n"); return -1; } memcpy(ehdr, oldhdr, offset); /* * check program header entries and update length * for merged PT_NOTE segments */ tot = 0; phdr_cnt = ehdr->e_phnum; debug("phdr_cnt=%d\n", phdr_cnt); for (i = 0; i < phdr_cnt; i++) { phdr = (Elf32_Phdr *) ((char *) ehdr + ehdr->e_ehsize + i * ehdr->e_phentsize); len = check_phdr(phdr); debug("prog hdr %d: %x ad %x len %x adjusted to %x\n", i, (u32) phdr, phdr->p_paddr, phdr->p_filesz, len); phdr->p_filesz = len; phdr->p_memsz = len; if (phdr->p_type == PT_NOTE) { /* note segment */ tot += len; notes_cnt++; } } debug("Length of %d note segments: %x\n", notes_cnt, tot); /* * all PT_NOTE segments have been merged into one. * Update ELF Header accordingly */ ehdr->e_phnum = phdr_cnt - notes_cnt + 1; /* write elf header into file on sdcard */ if (write_chunk(fd, ehdr, (size_t) ehdr->e_ehsize)) { free(ehdr); return -1; } /* write program headers into file on sdcard */ offset = ehdr->e_ehsize + ehdr->e_phentsize * ehdr->e_phnum; debug("Write Phdr: proghdr_cnt=%d\n", phdr_cnt); for (i = 0; i < phdr_cnt; i++) { phdr = (Elf32_Phdr *) ((char *)ehdr + ehdr->e_ehsize + i * ehdr->e_phentsize); save = phdr->p_filesz; if (i == 0) { phdr->p_filesz = tot; phdr->p_memsz = tot; } else if (phdr->p_type == PT_NOTE) /* note segment */ continue; phdr->p_offset = offset; debug("prog hdr %d: %x ad %x len %x off %x\n", i, (u32) phdr, phdr->p_paddr, phdr->p_filesz, phdr->p_offset); offset += phdr->p_filesz; if (write_chunk(fd, (void *) phdr, (size_t) ehdr->e_phentsize)) { free(ehdr); return -1; } phdr->p_filesz = save; phdr->p_memsz = save; } /* write segments into file on sdcard */ debug("write segments...\n"); for (i = 0; i < phdr_cnt; i++) { phdr = (Elf32_Phdr *) ((char *) ehdr + ehdr->e_ehsize + i * ehdr->e_phentsize); if (phdr->p_type > PT_NULL) { if (write_big_chunk(fd, (void *) phdr->p_paddr, phdr->p_filesz)) { free(ehdr); return -1; } } } free(ehdr); return 0; }
int ratt_table_push(ratt_table_t *table, void const *chunk) { RATTLOG_TRACE(); return write_chunk(table, chunk, ratt_table_get_tail_next); }
int ratt_table_insert(ratt_table_t *table, void const *chunk) { RATTLOG_TRACE(); return write_chunk(table, chunk, ratt_table_get_frag_first); }
static int winhttp_stream_write_chunked( git_smart_subtransport_stream *stream, const char *buffer, size_t len) { winhttp_stream *s = (winhttp_stream *)stream; int error; if (!s->request && winhttp_stream_connect(s) < 0) return -1; if (!s->sent_request) { /* Send Transfer-Encoding: chunked header */ if (!WinHttpAddRequestHeaders(s->request, transfer_encoding, (ULONG) -1L, WINHTTP_ADDREQ_FLAG_ADD)) { giterr_set(GITERR_OS, "Failed to add a header to the request"); return -1; } if ((error = send_request(s, 0, 1)) < 0) return error; s->sent_request = 1; } if (len > CACHED_POST_BODY_BUF_SIZE) { /* Flush, if necessary */ if (s->chunk_buffer_len > 0) { if (write_chunk(s->request, s->chunk_buffer, s->chunk_buffer_len) < 0) return -1; s->chunk_buffer_len = 0; } /* Write chunk directly */ if (write_chunk(s->request, buffer, len) < 0) return -1; } else { /* Append as much to the buffer as we can */ int count = (int)min(CACHED_POST_BODY_BUF_SIZE - s->chunk_buffer_len, len); if (!s->chunk_buffer) s->chunk_buffer = git__malloc(CACHED_POST_BODY_BUF_SIZE); memcpy(s->chunk_buffer + s->chunk_buffer_len, buffer, count); s->chunk_buffer_len += count; buffer += count; len -= count; /* Is the buffer full? If so, then flush */ if (CACHED_POST_BODY_BUF_SIZE == s->chunk_buffer_len) { if (write_chunk(s->request, s->chunk_buffer, s->chunk_buffer_len) < 0) return -1; s->chunk_buffer_len = 0; /* Is there any remaining data from the source? */ if (len > 0) { memcpy(s->chunk_buffer, buffer, len); s->chunk_buffer_len = (unsigned int)len; } } } return 0; }
static int winhttp_stream_read( git_smart_subtransport_stream *stream, char *buffer, size_t buf_size, size_t *bytes_read) { winhttp_stream *s = (winhttp_stream *)stream; winhttp_subtransport *t = OWNING_SUBTRANSPORT(s); DWORD dw_bytes_read; char replay_count = 0; int error; replay: /* Enforce a reasonable cap on the number of replays */ if (++replay_count >= 7) { giterr_set(GITERR_NET, "Too many redirects or authentication replays"); return -1; } /* Connect if necessary */ if (!s->request && winhttp_stream_connect(s) < 0) return -1; if (!s->received_response) { DWORD status_code, status_code_length, content_type_length, bytes_written; char expected_content_type_8[MAX_CONTENT_TYPE_LEN]; wchar_t expected_content_type[MAX_CONTENT_TYPE_LEN], content_type[MAX_CONTENT_TYPE_LEN]; if (!s->sent_request) { if ((error = send_request(s, s->post_body_len, 0)) < 0) return error; s->sent_request = 1; } if (s->chunked) { assert(s->verb == post_verb); /* Flush, if necessary */ if (s->chunk_buffer_len > 0 && write_chunk(s->request, s->chunk_buffer, s->chunk_buffer_len) < 0) return -1; s->chunk_buffer_len = 0; /* Write the final chunk. */ if (!WinHttpWriteData(s->request, "0\r\n\r\n", 5, &bytes_written)) { giterr_set(GITERR_OS, "Failed to write final chunk"); return -1; } } else if (s->post_body) { char *buffer; DWORD len = s->post_body_len, bytes_read; if (INVALID_SET_FILE_POINTER == SetFilePointer(s->post_body, 0, 0, FILE_BEGIN) && NO_ERROR != GetLastError()) { giterr_set(GITERR_OS, "Failed to reset file pointer"); return -1; } buffer = git__malloc(CACHED_POST_BODY_BUF_SIZE); while (len > 0) { DWORD bytes_written; if (!ReadFile(s->post_body, buffer, min(CACHED_POST_BODY_BUF_SIZE, len), &bytes_read, NULL) || !bytes_read) { git__free(buffer); giterr_set(GITERR_OS, "Failed to read from temp file"); return -1; } if (!WinHttpWriteData(s->request, buffer, bytes_read, &bytes_written)) { git__free(buffer); giterr_set(GITERR_OS, "Failed to write data"); return -1; } len -= bytes_read; assert(bytes_read == bytes_written); } git__free(buffer); /* Eagerly close the temp file */ CloseHandle(s->post_body); s->post_body = NULL; } if (!WinHttpReceiveResponse(s->request, 0)) { giterr_set(GITERR_OS, "Failed to receive response"); return -1; } /* Verify that we got a 200 back */ status_code_length = sizeof(status_code); if (!WinHttpQueryHeaders(s->request, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, WINHTTP_HEADER_NAME_BY_INDEX, &status_code, &status_code_length, WINHTTP_NO_HEADER_INDEX)) { giterr_set(GITERR_OS, "Failed to retrieve status code"); return -1; } /* The implementation of WinHTTP prior to Windows 7 will not * redirect to an identical URI. Some Git hosters use self-redirects * as part of their DoS mitigation strategy. Check first to see if we * have a redirect status code, and that we haven't already streamed * a post body. (We can't replay a streamed POST.) */ if (!s->chunked && (HTTP_STATUS_MOVED == status_code || HTTP_STATUS_REDIRECT == status_code || (HTTP_STATUS_REDIRECT_METHOD == status_code && get_verb == s->verb) || HTTP_STATUS_REDIRECT_KEEP_VERB == status_code)) { /* Check for Windows 7. This workaround is only necessary on * Windows Vista and earlier. Windows 7 is version 6.1. */ wchar_t *location; DWORD location_length; char *location8; /* OK, fetch the Location header from the redirect. */ if (WinHttpQueryHeaders(s->request, WINHTTP_QUERY_LOCATION, WINHTTP_HEADER_NAME_BY_INDEX, WINHTTP_NO_OUTPUT_BUFFER, &location_length, WINHTTP_NO_HEADER_INDEX) || GetLastError() != ERROR_INSUFFICIENT_BUFFER) { giterr_set(GITERR_OS, "Failed to read Location header"); return -1; } location = git__malloc(location_length); GITERR_CHECK_ALLOC(location); if (!WinHttpQueryHeaders(s->request, WINHTTP_QUERY_LOCATION, WINHTTP_HEADER_NAME_BY_INDEX, location, &location_length, WINHTTP_NO_HEADER_INDEX)) { giterr_set(GITERR_OS, "Failed to read Location header"); git__free(location); return -1; } /* Convert the Location header to UTF-8 */ if (git__utf16_to_8_alloc(&location8, location) < 0) { giterr_set(GITERR_OS, "Failed to convert Location header to UTF-8"); git__free(location); return -1; } git__free(location); /* Replay the request */ winhttp_stream_close(s); if (!git__prefixcmp_icase(location8, prefix_https)) { /* Upgrade to secure connection; disconnect and start over */ if (gitno_connection_data_from_url(&t->connection_data, location8, s->service_url) < 0) { git__free(location8); return -1; } winhttp_close_connection(t); if (winhttp_connect(t) < 0) return -1; } git__free(location8); goto replay; } /* Handle authentication failures */ if (HTTP_STATUS_DENIED == status_code && get_verb == s->verb) { int allowed_types; if (parse_unauthorized_response(s->request, &allowed_types, &t->auth_mechanism) < 0) return -1; if (allowed_types && (!t->cred || 0 == (t->cred->credtype & allowed_types))) { int cred_error = 1; /* Start with the user-supplied credential callback, if present */ if (t->owner->cred_acquire_cb) { cred_error = t->owner->cred_acquire_cb(&t->cred, t->owner->url, t->connection_data.user, allowed_types, t->owner->cred_acquire_payload); if (cred_error < 0) return cred_error; } /* Invoke the fallback credentials acquisition callback if necessary */ if (cred_error > 0) { cred_error = fallback_cred_acquire_cb(&t->cred, t->owner->url, t->connection_data.user, allowed_types, NULL); if (cred_error < 0) return cred_error; } if (!cred_error) { assert(t->cred); winhttp_stream_close(s); /* Successfully acquired a credential */ goto replay; } } } if (HTTP_STATUS_OK != status_code) { giterr_set(GITERR_NET, "Request failed with status code: %d", status_code); return -1; } /* Verify that we got the correct content-type back */ if (post_verb == s->verb) p_snprintf(expected_content_type_8, MAX_CONTENT_TYPE_LEN, "application/x-git-%s-result", s->service); else p_snprintf(expected_content_type_8, MAX_CONTENT_TYPE_LEN, "application/x-git-%s-advertisement", s->service); if (git__utf8_to_16(expected_content_type, MAX_CONTENT_TYPE_LEN, expected_content_type_8) < 0) { giterr_set(GITERR_OS, "Failed to convert expected content-type to wide characters"); return -1; } content_type_length = sizeof(content_type); if (!WinHttpQueryHeaders(s->request, WINHTTP_QUERY_CONTENT_TYPE, WINHTTP_HEADER_NAME_BY_INDEX, &content_type, &content_type_length, WINHTTP_NO_HEADER_INDEX)) { giterr_set(GITERR_OS, "Failed to retrieve response content-type"); return -1; } if (wcscmp(expected_content_type, content_type)) { giterr_set(GITERR_NET, "Received unexpected content-type"); return -1; } s->received_response = 1; } if (!WinHttpReadData(s->request, (LPVOID)buffer, (DWORD)buf_size, &dw_bytes_read)) { giterr_set(GITERR_OS, "Failed to read data"); return -1; } *bytes_read = dw_bytes_read; return 0; }
static int process_directory(int parent, const char *path, int fixstats, mkyaffs2image_callback callback) { DIR *dir; struct dirent *entry; //nDirectories++; dir = opendir(path); if(dir) { while((entry = readdir(dir)) != NULL) { /* Ignore . and .. */ if(strcmp(entry->d_name,".") && strcmp(entry->d_name,"..")) { char full_name[PATH_MAX]; struct stat stats; int equivalentObj; int newObj; sprintf(full_name,"%s/%s",path,entry->d_name); lstat(full_name,&stats); if(S_ISLNK(stats.st_mode) || S_ISREG(stats.st_mode) || S_ISDIR(stats.st_mode) || S_ISFIFO(stats.st_mode) || S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode) || S_ISSOCK(stats.st_mode)) { newObj = obj_id++; if (callback != NULL) callback(full_name); //nObjects++; if (fixstats) { fix_stat(full_name, &stats); } //printf("Object %d, %s is a ",newObj,full_name); /* We're going to create an object for it */ if((equivalentObj = find_obj_in_list(stats.st_dev, stats.st_ino)) > 0) { /* we need to make a hard link */ //printf("hard link to object %d\n",equivalentObj); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_HARDLINK, &stats, parent, entry->d_name, equivalentObj, NULL); } else { add_obj_to_list(stats.st_dev,stats.st_ino,newObj); if(S_ISLNK(stats.st_mode)) { char symname[PATH_MAX]; memset(symname,0, sizeof(symname)); readlink(full_name,symname,sizeof(symname) -1); //printf("symlink to \"%s\"\n",symname); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SYMLINK, &stats, parent, entry->d_name, -1, symname); } else if(S_ISREG(stats.st_mode)) { //printf("file, "); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_FILE, &stats, parent, entry->d_name, -1, NULL); if(error >= 0) { int h; __u8 bytes[chunkSize]; int nBytes; int chunk = 0; h = open(full_name,O_RDONLY); if(h >= 0) { memset(bytes,0xff,sizeof(bytes)); while((nBytes = read(h,bytes,sizeof(bytes))) > 0) { chunk++; write_chunk(bytes,newObj,chunk,nBytes); memset(bytes,0xff,sizeof(bytes)); } if(nBytes < 0) error = nBytes; //printf("%d data chunks written\n",chunk); } else { perror("Error opening file"); } close(h); } } else if(S_ISSOCK(stats.st_mode)) { //printf("socket\n"); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL); } else if(S_ISFIFO(stats.st_mode)) { //printf("fifo\n"); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL); } else if(S_ISCHR(stats.st_mode)) { //printf("character device\n"); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL); } else if(S_ISBLK(stats.st_mode)) { //printf("block device\n"); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL); } else if(S_ISDIR(stats.st_mode)) { //printf("directory\n"); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_DIRECTORY, &stats, parent, entry->d_name, -1, NULL); // NCB modified 10/9/2001 process_directory(1,full_name); process_directory(newObj,full_name,fixstats,callback); } } } else { //printf(" we don't handle this type\n"); } } } closedir(dir); } return 0; }
int main(int argc, char **argv) { boot_img_hdr hdr; int bootimg_fd; void *boot_data = 0; unsigned boot_size = 0; char boot_magic[BOOT_MAGIC_SIZE+1]; char kernel_fn[MAXNAMELEN]; void *kernel_data = 0; char ramdisk_fn[MAXNAMELEN]; void *ramdisk_data = 0; char second_fn[MAXNAMELEN]; void *second_data = 0; char header_fn[MAXNAMELEN]; char *cmdline = ""; char *bootimg_fn = 0; char *board = ""; unsigned pagesize = 2048; int fd; /*SHA_CTX ctx;*/ /*uint8_t* sha;*/ unsigned long i; unsigned count; char *msg1 = ""; char *msg2 = ""; int offset; FILE *fp; unsigned kernel_offset = 0x00008000; unsigned ramdisk_offset = 0x01000000; unsigned second_offset = 0x00F00000; unsigned tags_offset = 0x00000100; unsigned kernel_base = 0; unsigned ramdisk_base = 0; unsigned second_base = 0; unsigned tags_base = 0; argc--; argv++; while(argc > 0){ char *arg = argv[0]; char *val = argv[1]; if(argc < 2) { return usage(); } argc -= 2; argv += 2; if(!strcmp(arg, "--input") || !strcmp(arg, "-i")) { bootimg_fn = val; } else { return usage(); } } if(bootimg_fn == 0) { fprintf(stderr,"error: no input filename specified\n"); return usage(); } sprintf(kernel_fn, "%s-kernel", bootimg_fn); bootimg_fd = open(bootimg_fn, O_RDONLY); if (bootimg_fd < 0) { fprintf(stderr,"error: could not open %s\n", bootimg_fn); return 1; } count = read(bootimg_fd, (void *)&hdr, sizeof(hdr)); if (count != sizeof(hdr)) { msg1 = "could not read hdr from input"; goto fail; } for (i = 0; i < BOOT_MAGIC_SIZE; i++) { boot_magic[i] = hdr.magic[i]; } boot_magic[BOOT_MAGIC_SIZE] = '\0'; if (strcmp(BOOT_MAGIC, boot_magic)) { fprintf(stderr, "error: %s boot image file's magic value %s does not match %s\n", bootimg_fn, boot_magic, BOOT_MAGIC); goto fail; } if (hdr.page_size != 2048 && hdr.page_size != 4096 && hdr.page_size != 8192 && hdr.page_size != 16384) { fprintf(stderr, "warning: hdr.page_size %d must be 2048, 4096, 8192 or 16384\n", hdr.page_size); goto fail; } count = lseek(bootimg_fd, hdr.page_size, SEEK_SET); if (count != hdr.page_size) { msg1 = "boot header is not a page"; goto fail; } sprintf(header_fn, "%s-header", bootimg_fn); fp = fopen(header_fn, "w+"); if(!fp) { msg1 = "could not create"; msg2 = header_fn; goto fail; } kernel_base = hdr.kernel_addr - kernel_offset; ramdisk_base = hdr.ramdisk_addr - ramdisk_offset; second_base = hdr.second_addr - second_offset; tags_base = hdr.tags_addr - tags_offset; fprintf(fp, "Assumptions\n"); fprintf(fp, "kernel_offset = 0x%X\n", kernel_offset); fprintf(fp, "ramdisk_offset = 0x%X\n", ramdisk_offset); fprintf(fp, "second_offset = 0x%X\n", second_offset); fprintf(fp, "tags_offset = 0x%X\n", tags_offset); fprintf(fp, "Detected values\n"); fprintf(fp, "kernel_size = %d\n", hdr.kernel_size); fprintf(fp, "kernel_addr = 0x%X\n", hdr.kernel_addr); fprintf(fp, "ramdisk_size = %d\n", hdr.ramdisk_size); fprintf(fp, "ramdisk_addr = 0x%X\n", hdr.ramdisk_addr); fprintf(fp, "second_size = %d\n", hdr.second_size); fprintf(fp, "second_addr = 0x%X\n", hdr.second_addr); fprintf(fp, "tags_addr = 0x%X\n", hdr.tags_addr); fprintf(fp, "page_size = %d\n", hdr.page_size); /*fprintf(fp, "unused = %d%d\n", hdr.unused[0], hdr.unused[1]);*/ fprintf(fp, "name/board = %s\n", hdr.name); fprintf(fp, "cmdline = %s\n", hdr.cmdline); /*fprintf(fp, "id = %s\n", hdr.id);*/ fprintf(fp, "Computed values\n"); fprintf(fp, "kernel_base = 0x%X\n", kernel_base); fprintf(fp, "ramdisk_base = 0x%X, kernel_base - ramdisk_offset=0x%X\n", ramdisk_base, kernel_base - ramdisk_base); fprintf(fp, "second_base = 0x%X, kernel_base - second_offset=0x%X\n", second_base, kernel_base - second_base); fprintf(fp, "tags_base = 0x%X, kernel_base - tags_offset = 0x%X\n", tags_base, kernel_base - tags_base); if (kernel_base != ramdisk_base || kernel_base != second_base || kernel_base != tags_base) { fprintf(fp, "WARNING! base addresses do not match!\n"); fprintf(stderr, "WARNING! base addresses do not match!\n"); } fclose(fp); /* kernel */ if(hdr.kernel_size == 0) { msg1 = "kernel size is zero"; goto fail; } offset = hdr.page_size; write_chunk(bootimg_fd, bootimg_fn, hdr.kernel_size, "kernel", offset); /* ramdisk */ if(hdr.ramdisk_size == 0) { msg1 = "ramdisk size is zero"; goto fail; } offset += pages(hdr.page_size, hdr.kernel_size) * hdr.page_size; write_chunk(bootimg_fd, bootimg_fn, hdr.ramdisk_size, "first-ramdisk", offset); /* ramdisk 2 */ if(hdr.second_size > 0) { offset += pages(hdr.page_size, hdr.ramdisk_size) * hdr.page_size; write_chunk(bootimg_fd, bootimg_fn, hdr.second_size, "second-ramdisk", offset); } return 0; fail: close(bootimg_fd); fprintf(stderr,"error: %s %s '%s': %s\n", msg1, msg2, bootimg_fn, strerror(errno)); return 1; }
static int http_stream_write_chunked( git_smart_subtransport_stream *stream, const char *buffer, size_t len) { http_stream *s = (http_stream *)stream; http_subtransport *t = OWNING_SUBTRANSPORT(s); assert(t->connected); /* Send the request, if necessary */ if (!s->sent_request) { git_buf request = GIT_BUF_INIT; clear_parser_state(t); if (gen_request(&request, s, 0) < 0) { giterr_set(GITERR_NET, "Failed to generate request"); return -1; } if (gitno_send(&t->socket, request.ptr, request.size, 0) < 0) { git_buf_free(&request); return -1; } git_buf_free(&request); s->sent_request = 1; } if (len > CHUNK_SIZE) { /* Flush, if necessary */ if (s->chunk_buffer_len > 0) { if (write_chunk(&t->socket, s->chunk_buffer, s->chunk_buffer_len) < 0) return -1; s->chunk_buffer_len = 0; } /* Write chunk directly */ if (write_chunk(&t->socket, buffer, len) < 0) return -1; } else { /* Append as much to the buffer as we can */ int count = min(CHUNK_SIZE - s->chunk_buffer_len, len); if (!s->chunk_buffer) s->chunk_buffer = git__malloc(CHUNK_SIZE); memcpy(s->chunk_buffer + s->chunk_buffer_len, buffer, count); s->chunk_buffer_len += count; buffer += count; len -= count; /* Is the buffer full? If so, then flush */ if (CHUNK_SIZE == s->chunk_buffer_len) { if (write_chunk(&t->socket, s->chunk_buffer, s->chunk_buffer_len) < 0) return -1; s->chunk_buffer_len = 0; if (len > 0) { memcpy(s->chunk_buffer, buffer, len); s->chunk_buffer_len = len; } } } return 0; }
static int winhttp_stream_write_chunked( git_smart_subtransport_stream *stream, const char *buffer, size_t len) { winhttp_stream *s = (winhttp_stream *)stream; winhttp_subtransport *t = OWNING_SUBTRANSPORT(s); if (!s->request && winhttp_stream_connect(s) < 0) return -1; if (!s->sent_request) { /* Send Transfer-Encoding: chunked header */ if (!WinHttpAddRequestHeaders(s->request, transfer_encoding, (ULONG) -1L, WINHTTP_ADDREQ_FLAG_ADD)) { giterr_set(GITERR_OS, QT_TRANSLATE_NOOP("libgit2", "Failed to add a header to the request")); return -1; } if (!WinHttpSendRequest(s->request, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, WINHTTP_IGNORE_REQUEST_TOTAL_LENGTH, 0)) { giterr_set(GITERR_OS, QT_TRANSLATE_NOOP("libgit2", "Failed to send request")); return -1; } s->sent_request = 1; } if (len > CACHED_POST_BODY_BUF_SIZE) { /* Flush, if necessary */ if (s->chunk_buffer_len > 0) { if (write_chunk(s->request, s->chunk_buffer, s->chunk_buffer_len) < 0) return -1; s->chunk_buffer_len = 0; } /* Write chunk directly */ if (write_chunk(s->request, buffer, len) < 0) return -1; } else { /* Append as much to the buffer as we can */ int count = min(CACHED_POST_BODY_BUF_SIZE - s->chunk_buffer_len, (int)len); if (!s->chunk_buffer) s->chunk_buffer = git__malloc(CACHED_POST_BODY_BUF_SIZE); memcpy(s->chunk_buffer + s->chunk_buffer_len, buffer, count); s->chunk_buffer_len += count; buffer += count; len -= count; /* Is the buffer full? If so, then flush */ if (CACHED_POST_BODY_BUF_SIZE == s->chunk_buffer_len) { if (write_chunk(s->request, s->chunk_buffer, s->chunk_buffer_len) < 0) return -1; s->chunk_buffer_len = 0; /* Is there any remaining data from the source? */ if (len > 0) { memcpy(s->chunk_buffer, buffer, len); s->chunk_buffer_len = (unsigned int)len; } } } return 0; }
static int process_directory(int parent, const char *path, int fixstats) { DIR *dir; struct dirent *entry; char *secontext = NULL; nDirectories++; dir = opendir(path); if(dir) { while((entry = readdir(dir)) != NULL) { /* Ignore . and .. */ if(strcmp(entry->d_name,".") && strcmp(entry->d_name,"..")) { char full_name[500]; char *suffix, dest_name[500]; int ret; struct stat stats; int equivalentObj; int newObj; sprintf(full_name,"%s/%s",path,entry->d_name); lstat(full_name,&stats); if (sehnd) { suffix = full_name + seprefixlen; ret = snprintf(dest_name, sizeof dest_name, "%s%s", mntpoint, suffix); if (ret < 0 || (size_t) ret >= sizeof dest_name) { fprintf(stderr, "snprintf failed on %s%s\n", mntpoint, suffix); exit(1); } char *sepath = NULL; if (dest_name[0] == '/') sepath = strdup(dest_name); else if (asprintf(&sepath, "/%s", dest_name) < 0) sepath = NULL; if (!sepath) { perror("malloc"); exit(1); } if (selabel_lookup(sehnd, &secontext, sepath, stats.st_mode) < 0) { perror("selabel_lookup"); free(sepath); exit(1); } free(sepath); } if(S_ISLNK(stats.st_mode) || S_ISREG(stats.st_mode) || S_ISDIR(stats.st_mode) || S_ISFIFO(stats.st_mode) || S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode) || S_ISSOCK(stats.st_mode)) { newObj = obj_id++; nObjects++; if (fixstats) { fix_stat(full_name, &stats); } //printf("Object %d, %s is a ",newObj,full_name); /* We're going to create an object for it */ if((equivalentObj = find_obj_in_list(stats.st_dev, stats.st_ino)) > 0) { /* we need to make a hard link */ //printf("hard link to object %d\n",equivalentObj); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_HARDLINK, &stats, parent, entry->d_name, equivalentObj, NULL, secontext); } else { add_obj_to_list(stats.st_dev,stats.st_ino,newObj); if(S_ISLNK(stats.st_mode)) { char symname[500]; memset(symname,0, sizeof(symname)); readlink(full_name,symname,sizeof(symname) -1); //printf("symlink to \"%s\"\n",symname); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SYMLINK, &stats, parent, entry->d_name, -1, symname, secontext); } else if(S_ISREG(stats.st_mode)) { //printf("file, "); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_FILE, &stats, parent, entry->d_name, -1, NULL, secontext); if(error >= 0) { int h; __u8 bytes[chunkSize]; int nBytes; int chunk = 0; h = open(full_name,O_RDONLY); if(h >= 0) { memset(bytes,0xff,sizeof(bytes)); while((nBytes = read(h,bytes,sizeof(bytes))) > 0) { chunk++; write_chunk(bytes,newObj,chunk,nBytes); memset(bytes,0xff,sizeof(bytes)); } if(nBytes < 0) error = nBytes; //printf("%d data chunks written\n",chunk); } else { perror("Error opening file"); } close(h); } } else if(S_ISSOCK(stats.st_mode)) { //printf("socket\n"); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL, secontext); } else if(S_ISFIFO(stats.st_mode)) { //printf("fifo\n"); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL, secontext); } else if(S_ISCHR(stats.st_mode)) { //printf("character device\n"); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL, secontext); } else if(S_ISBLK(stats.st_mode)) { //printf("block device\n"); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL, secontext); } else if(S_ISDIR(stats.st_mode)) { //printf("directory\n"); error = write_object_header(newObj, YAFFS_OBJECT_TYPE_DIRECTORY, &stats, parent, entry->d_name, -1, NULL, secontext); // NCB modified 10/9/2001 process_directory(1,full_name); process_directory(newObj,full_name,fixstats); } } } else { //printf(" we don't handle this type\n"); } } } closedir(dir); } return 0; }
static void lts_write_dir(archive_t archive,string_map_t map,lts_t lts,int segments){ if (map) arch_set_write_policy(archive,map); dir_info_t info=DIRinfoCreate(segments); int i,j; uint32_t k; char filename[1024]; stream_t output; stream_t *src_out; stream_t *lbl_out; stream_t *dst_out; if (lts->root_count !=1) Abort("LTS has %u initial states DIR requires 1",lts->root_count); lts_set_type(lts,LTS_BLOCK); info->label_tau=lts->tau; int type_no=lts_type_get_edge_label_typeno(lts->ltstype,0); switch(lts_type_get_format(lts->ltstype,type_no)){ case LTStypeChunk: case LTStypeEnum: break; default: Abort("DIR is limited to Chunk/Enum edge labels."); } info->label_count=VTgetCount(lts->values[type_no]); info->initial_seg=lts->root_list[0]%segments; info->initial_ofs=lts->root_list[0]/segments; output=arch_write(archive,"TermDB"); int last_idx = 0; table_iterator_t it = VTiterator (lts->values[type_no]); while (IThasNext(it)) { chunk label_c = ITnext (it); int idx = VTputChunk (lts->values[type_no], label_c); while (last_idx < idx) { // fill non-dense indices write_chunk (output, (chunk){0, ""}); last_idx++; } write_chunk (output, label_c); } DSclose(&output); src_out=(stream_t*)RTmalloc(segments*sizeof(stream_t)); lbl_out=(stream_t*)RTmalloc(segments*sizeof(stream_t)); dst_out=(stream_t*)RTmalloc(segments*sizeof(stream_t)); for(i=0;i<segments;i++) { for(j=0;j<segments;j++) { sprintf(filename,"src-%d-%d",i,j); src_out[j]=arch_write(archive,filename); sprintf(filename,"label-%d-%d",i,j); lbl_out[j]=arch_write(archive,filename); sprintf(filename,"dest-%d-%d",i,j); dst_out[j]=arch_write(archive,filename); } for(j=i;j<(int)lts->states;j+=segments){ for(k=lts->begin[j];k<lts->begin[j+1];k++){ int dseg=(lts->dest[k])%segments; info->transition_count[i][dseg]++; DSwriteU32(src_out[dseg],info->state_count[i]); DSwriteU32(lbl_out[dseg],lts->label[k]); DSwriteU32(dst_out[dseg],(lts->dest[k])/segments); } info->state_count[i]++; } for(j=0;j<segments;j++) { DSclose(&src_out[j]); DSclose(&lbl_out[j]); DSclose(&dst_out[j]); } } info->info="bsim2 output"; output=arch_write(archive,"info"); DIRinfoWrite(output,info); DSclose(&output); info->info=NULL; DIRinfoDestroy(info); }
static int http_stream_read( git_smart_subtransport_stream *stream, char *buffer, size_t buf_size, size_t *bytes_read) { http_stream *s = (http_stream *)stream; http_subtransport *t = OWNING_SUBTRANSPORT(s); parser_context ctx; size_t bytes_parsed; replay: *bytes_read = 0; assert(t->connected); if (!s->sent_request) { git_buf request = GIT_BUF_INIT; clear_parser_state(t); if (gen_request(&request, s, 0) < 0) { giterr_set(GITERR_NET, "Failed to generate request"); return -1; } if (gitno_send(&t->socket, request.ptr, request.size, 0) < 0) { git_buf_free(&request); return -1; } git_buf_free(&request); s->sent_request = 1; } if (!s->received_response) { if (s->chunked) { assert(s->verb == post_verb); /* Flush, if necessary */ if (s->chunk_buffer_len > 0 && write_chunk(&t->socket, s->chunk_buffer, s->chunk_buffer_len) < 0) return -1; s->chunk_buffer_len = 0; /* Write the final chunk. */ if (gitno_send(&t->socket, "0\r\n\r\n", 5, 0) < 0) return -1; } s->received_response = 1; } while (!*bytes_read && !t->parse_finished) { t->parse_buffer.offset = 0; if (gitno_recv(&t->parse_buffer) < 0) return -1; /* This call to http_parser_execute will result in invocations of the * on_* family of callbacks. The most interesting of these is * on_body_fill_buffer, which is called when data is ready to be copied * into the target buffer. We need to marshal the buffer, buf_size, and * bytes_read parameters to this callback. */ ctx.t = t; ctx.s = s; ctx.buffer = buffer; ctx.buf_size = buf_size; ctx.bytes_read = bytes_read; /* Set the context, call the parser, then unset the context. */ t->parser.data = &ctx; bytes_parsed = http_parser_execute(&t->parser, &t->settings, t->parse_buffer.data, t->parse_buffer.offset); t->parser.data = NULL; /* If there was a handled authentication failure, then parse_error * will have signaled us that we should replay the request. */ if (PARSE_ERROR_REPLAY == t->parse_error) { s->sent_request = 0; if (http_connect(t) < 0) return -1; goto replay; } if (t->parse_error < 0) return -1; if (bytes_parsed != t->parse_buffer.offset) { giterr_set(GITERR_NET, "HTTP parser error: %s", http_errno_description((enum http_errno)t->parser.http_errno)); return -1; } } return 0; }