struct Connection *Database_open(const char *filename, char mode) { struct Connection *conn = malloc(sizeof(struct Connection)); check_mem(conn); check_debug(conn, "Memory error"); conn->db = malloc(sizeof(struct Database)); check_mem(conn); check_debug(conn->db, "Memory error"); if(mode == 'c') { conn->file = fopen(filename, "w"); } else { conn->file = fopen(filename, "r+"); if(conn->file) { Database_load(conn); } } check_debug(conn->file, "Failed to open file"); error: if(conn->db) free(conn->db); if(conn->file) fclose(conn->file); }
bool dl_del(list_t *list, char *new_word){ check_debug(list != NULL, "List is NULL."); check_debug(list->prev != NULL && list->next != NULL, "List is empty."); check_debug(list->prev != list && list->next != list, "List is empty."); list_t *node = NULL; node = list->next; bool result = 0; while(node != list){ list_t *next_node = node->next; check_debug(next_node != NULL && node->prev != NULL, "Invalid list, node: %s, node->prev: %s", next_node == NULL ? "NULL" : "VALID", node->prev == NULL ? "NULL" : "VALID"); if(strcmp(node->word,new_word) == 0){ check_debug(dl_remove(list, node) == 1, "Could not delete node."); result = 1; } node = next_node; } return result; error: return 0; }
int Dir_stream_file(FileRecord *file, Connection *conn) { ssize_t sent = 0; size_t total = 0; off_t offset = 0; size_t block_size = MAX_SEND_BUFFER; // For the non-sendfile slowpath char *file_buffer = NULL; int nread = 0; int amt = 0; int tempfd = -1; int rc = Dir_send_header(file, conn); check_debug(rc, "Failed to write header to socket."); if(conn->ssl == NULL) { for(total = 0; fdwait(conn->fd, 'w') == 0 && total < file->sb.st_size; total += sent) { sent = Dir_send(conn->fd, file->fd, &offset, block_size); check_debug(sent > 0, "Failed to sendfile on socket: %d from " "file %d", conn->fd, file->fd); } } else { // We have to reopen the file, so we don't get ourselves into seek // position trouble int tempfd = open((const char *)(file->full_path->data), O_RDONLY); check(tempfd >= 0, "Could not reopen open file"); file_buffer = malloc(MAX_SEND_BUFFER); check_mem(file_buffer); while((nread = fdread(tempfd, file_buffer, MAX_SEND_BUFFER)) > 0) { for(amt = 0, sent = 0; sent < nread; sent += amt) { amt = conn->send(conn, file_buffer + sent, nread - sent); check_debug(amt > 0, "Failed to send on socket: %d from " "file %d", conn->fd, tempfd); } total += nread; } free(file_buffer); close(tempfd); tempfd = -1; } check(total <= file->sb.st_size, "Wrote way too much, wrote %d but size was %d", (int)total, (int)file->sb.st_size); check(total == file->sb.st_size, "Sent other than expected, sent: %d, but expected: %d", (int)total, (int)file->sb.st_size); return total; error: if(file_buffer) free(file_buffer); if(tempfd >= 0) close(tempfd); return -1; }
/* --------------------------------------------------- */ public struct xml_element * xsd_type( struct xml_element * xsd, char * nptr ) { struct xml_element * wptr=(struct xml_element *) 0; struct xml_element * tptr=(struct xml_element *) 0; struct xml_atribut * aptr; char * vptr; if ( check_debug() ) { printf("xsd:type( %s )\n",nptr); } for ( wptr = document_element( xsd, _XSD_COMPLEX ); wptr != (struct xml_element *) 0; wptr = wptr->next ) { if ( strcasecmp( wptr->name, _XSD_COMPLEX ) ) continue; else if (!( aptr = document_atribut( wptr, _XSD_NAME ) )) continue; else if (!( aptr->value )) continue; else if (!( vptr = occi_unquoted_value( aptr->value ) )) continue; else if (!( strcmp( vptr, nptr ) )) { liberate( vptr ); return( wptr ); } else { liberate( vptr ); continue; } } if ( check_debug() ) { printf("xsd:failure( attribute %s )\n",nptr); } return( wptr ); }
int connection_proxy_req_parse(Connection *conn) { int rc = 0; Host *target_host = conn->req->target_host; Backend *req_action = conn->req->action; check_debug(!IOBuf_closed(conn->iob), "Client closed, goodbye."); rc = Connection_read_header(conn, conn->req); check_debug(rc > 0, "Failed to read another header."); error_unless(Request_is_http(conn->req), conn, 400, "Someone tried to change the protocol on us from HTTP."); Backend *found = Host_match_backend(target_host, Request_path(conn->req), NULL); error_unless(found, conn, 404, "Handler not found: %s", bdata(Request_path(conn->req))); // break out of PROXY if the actions don't match if(found != req_action) { Request_set_action(conn->req, found); return Connection_backend_event(found, conn); } else { return HTTP_REQ; } error_response(conn, 500, "Invalid code branch, tell Zed."); error: return REMOTE_CLOSE; }
/** * Streams data out of the from IOBuf and into the to IOBuf * until it's moved total bytes between them. */ int IOBuf_stream(IOBuf *from, IOBuf *to, int total) { int need = 0; int remain = total; int avail = 0; int rc = 0; char *data = NULL; if(from->len > to->len) IOBuf_resize(to, from->len); while(remain > 0) { need = remain <= from->len ? remain : from->len; data = IOBuf_read(from, need, &avail); check_debug(avail > 0, "Nothing in read buffer."); rc = IOBuf_send_all(to, IOBuf_start(from), avail); check_debug(rc == avail, "Failed to send all of the data: %d of %d", rc, avail) // commit whatever we just did check(IOBuf_read_commit(from, rc) != -1, "Final commit failed during streaming."); // reduce it by the given amount remain -= rc; } assert(remain == 0 && "Buffer math is wrong."); return total - remain; error: return -1; }
FileRecord *Dir_resolve_file(Dir *dir, bstring path) { FileRecord *file = NULL; bstring target = NULL; check(Dir_lazy_normalize_base(dir) == 0, "Failed to normalize base path when requesting %s", bdata(path)); check(bstrncmp(path, dir->prefix, blength(dir->prefix)) == 0, "Request for path %s does not start with %s prefix.", bdata(path), bdata(dir->prefix)); file = FileRecord_cache_check(dir, path); if(file) { // TODO: double check this gives the right users count file->users++; return file; } // We subtract one from the blengths below, because dir->prefix includes // a trailing '/'. If we skip over this in path->data, we drop the '/' // from the URI, breaking the target path if(bchar(path, blength(path) - 1) == '/') { target = bformat("%s%s%s", bdata(dir->normalized_base), path->data + blength(dir->prefix) - 1, bdata(dir->index_file)); } else { target = bformat("%s%s", bdata(dir->normalized_base), path->data + blength(dir->prefix) - 1); } check(target, "Couldn't construct target path for %s", bdata(path)); check_debug(normalize_path(target) == 0, "Failed to normalize target path."); check_debug(bstrncmp(target, dir->normalized_base, blength(dir->normalized_base)) == 0, "Request for path %s does not start with %s base after normalizing.", bdata(target), bdata(dir->base)); // the FileRecord now owns the target file = Dir_find_file(target, dir->default_ctype); check_debug(file, "Error opening file: %s", bdata(target)); // Increment the user count because we're adding it to the cache file->users++; file->request_path = bstrcpy(path); Cache_add(dir->fr_cache, file); return file; error: bdestroy(target); FileRecord_release(file); return NULL; }
char *dl_get_front(list_t *list){ check_debug(list != NULL, "List is NULL."); check_debug(list->next != NULL && list->next != list, "List is empty."); check_debug(list->next->word != NULL, "list->next->word is NULL."); return list->next->word; error: return NULL; }
bool dl_pop_back(list_t *list){ check_debug(list != NULL, "List is NULL."); check_debug(list->prev != NULL && list->prev != list, "List is empty."); check_debug(dl_remove(list, list->prev) == 1, "Delete from back was not successful."); return 1; error: return 0; }
bool dl_pop_front(list_t *list){ check_debug(list != NULL, "List is NULL."); check_debug(list->next != NULL && list->next != list, "List is empty."); check_debug(dl_remove(list, list->next) == 1, "Delete from front was not successful."); return 1; error: return 0; }
char *dl_get_back(list_t *list){ check_debug(list != NULL, "List is NULL."); check_debug(list->prev != NULL && list->prev != list, "List is empty."); check_debug(list->prev->word != NULL, "list->prev->word is NULL."); return list->prev->word; error: return 0; }
int main(int argc, const char *argv[]) { fd_set allreads; fd_set readmask; int socket = 0; int rc = 0; RingBuffer *in_rb = RingBuffer_create(1024 * 10); RingBuffer *sock_rb = RingBuffer_create(1024 * 10); check(argc == 3, "USAGE: netclient HOST PORT"); socket = client_connect(argv[1], argv[2]); check(socket >= 0, "Connect to %s:%s failed.", argv[1], argv[2]); FD_ZERO(&allreads); FD_SET(socket, &allreads); FD_SET(0, &allreads); while(1) { readmask = allreads; rc = select(socket + 1, &readmask, NULL, NULL, NULL); check(rc >= 0, "Select failed"); if(FD_ISSET(0, &readmask)) { rc = read_some(in_rb, 0, 0); check_debug(rc != -1, "failed to read from stdin."); } if(FD_ISSET(socket, &readmask)) { rc = read_some(sock_rb, socket, 0); check_debug(rc != -1, "failed to read from socket."); } while(!RingBuffer_empty(sock_rb)) { rc = write_some(sock_rb, 1, 0); check_debug(rc != -1, "failed to write to stdout."); } while(!RingBuffer_empty(in_rb)) { rc = write_some(in_rb, socket, 1); check_debug(rc != -1, "failed to write to socket."); } } RingBuffer_destroy(in_rb); RingBuffer_destroy(sock_rb); return 0; error: return -1; }
static inline int Connection_deliver_enqueue(Connection *conn, bstring b) { check_debug(conn->deliverPost-conn->deliverAck < DELIVER_OUTSTANDING_MSGS, "Too many outstanding messages") ; check_debug(conn->deliverTaskStatus==DT_RUNNING, "Cannot enqueue, deliver task not running"); conn->deliverRing[conn->deliverPost++%DELIVER_OUTSTANDING_MSGS]=b; taskwakeup(&conn->deliverRendez); return 0; error: return -1; }
bool dl_sort(list_t *list){ check_debug(list != NULL, "list is null."); check_debug(list->prev != NULL && list->next != NULL && list->prev != list && list->next != list, "list is empty."); while(bubble_sort(list) != 1){} return 1; error: return 0; }
int Register_fd_for_id(uint32_t id) { RMElement *el = RadixMap_find(REG_ID_TO_FD, id); check_debug(el != NULL, "Id %d not registered.", id); Registration *reg = darray_get(REGISTRATIONS, el->data.value); check_debug(Register_valid(reg), "Nothing registered under id %d.", id); return reg->fd; error: return -1; }
int dl_get_wordcount(list_t *list, char *word){ check_debug(list != NULL, "list is NULL."); check_debug(word != NULL, "word is NULL"); list_t *node = NULL; node = dl_check(list, word); check_debug(node != NULL, "word '%s' not in list.", word); return node->word_count; error: return 0; }
static VALUE method_get_next_event(VALUE self, VALUE blocking) { // dbg.h check_debug(!is_closed(self), "we are closed, not trying to get event"); char buf[64]; FETCH_DATA_PTR(self, zk); for (;;) { check_debug(!is_closed(self), "we're closed in the middle of method_get_next_event, bailing"); zkrb_event_t *event = zkrb_dequeue(zk->queue, 1); /* Wait for an event using rb_thread_select() on the queue's pipe */ if (event == NULL) { if (NIL_P(blocking) || (blocking == Qfalse)) { goto error; } else { // if we're shutting down, don't enter this section, we don't want to block check_debug(!is_shutting_down(self), "method_get_next_event, we're shutting down, don't enter blocking section"); int fd = zk->queue->pipe_read; ssize_t bytes_read = 0; // wait for an fd to become readable, opposite of rb_thread_fd_writable rb_thread_wait_fd(fd); // clear all bytes here, we'll catch all the events on subsequent calls // (until we run out of events) bytes_read = read(fd, buf, sizeof(buf)); if (bytes_read == -1) { rb_raise(rb_eRuntimeError, "read failed: %d", errno); } zkrb_debug_inst(self, "read %zd bytes from the queue (%p)'s pipe", bytes_read, zk->queue); continue; } } VALUE hash = zkrb_event_to_ruby(event); zkrb_event_free(event); return hash; } error: return Qnil; }
static ssize_t plain_stream_file(IOBuf *iob, int fd, off_t len) { off_t sent = 0; off_t total = 0; off_t offset = 0; off_t block_size = MAX_SEND_BUFFER; int conn_fd = IOBuf_fd(iob); for(total = 0; fdwait(conn_fd, 'w') == 0 && total < len; total += sent) { block_size = (len - total) > block_size ? block_size : (len - total); sent = IOBuf_sendfile(conn_fd, fd, &offset, block_size); check(Register_write(iob->fd, sent) != -1, "Socket seems to be closed."); check_debug(sent > 0, "Client closed probably during sendfile on socket: %d from " "file %d", conn_fd, fd); } check(total <= len, "Wrote way too much, wrote %d but size was %zd", (int)total, len); check(total == len, "Sent other than expected, sent: %d, but expected: %zd", (int)total, len); return total; error: return -1; }
int AST_walk_hash(tst_t *settings, Value *data, ast_hash_walk_cb cb) { struct ASTScanData scan = {.settings = settings, .cb = cb, .error = 0}; tst_traverse(data->as.hash, ast_hash_traverse_cb, &scan); return scan.error; } Value *AST_get(tst_t *settings, tst_t *fr, bstring name, ValueType type) { Pair *pair = tst_search(fr, bdata(name), blength(name)); check_debug(pair, "Couldn't find variable %s of type %s", bdata(name), Value_type_name(type)); Value *val = Pair_value(pair); if(Value_is(val, REF)) { val = Value_resolve(settings, val); check(val, "Couldn't find variable %s of type %s", bdata(name), Value_type_name(type)); } check(val->type == type, "Invalid type for %s, should be %s not %s", bdata(name), Value_type_name(type), Value_type_name(val->type)); return val; error: return NULL; }
int main(int argc, char *argv[]) { bstring url = NULL; bstring route = NULL; TSTree *routes = NULL; check(argc == 2, "USAGE: urlor <urlfile>"); routes = load_routes(argv[1]); check(routes != NULL, "Your route file has an error."); while (1) { url = read_line("URL> "); check_debug(url != NULL, "goodbye."); route = match_url(routes, url); if (route) { printf("MATCH: %s == %s\n", bdata(url), bdata(route)); } else { printf("FAIL: %s\n", bdata(url)); } bdestroy(url); } destroy_routes(routes); return 0; error: destroy_routes(routes); return 1; }
int main(int ac, char **av) { unsigned char board[MEM_SIZE]; t_vm *vm; t_dlist *list; t_dlist *list_s; if (ac < 2) return (0); list = NULL; list_s = NULL; list = new_list(list); list_s = new_list(list_s); init_board(board); vm = NULL; vm = new_vm(vm); fill_list(list, av); check_debug(list, vm); syntax(list); find_dump(list, vm); find_champ(list, vm, board, 0); id_champ(vm); champ_id_reg(vm); init_alive(vm); start_vm(vm, board); winning(vm); return (0); }
int main(int argc , char *argv[]) { /*just echo the prompt and wait for a line to be enterred in *then search the url as the key to find data * then output */ bstring url = NULL ; bstring route = NULL; check(argc == 2 , "usage: urlor <urlfile>"); TSTree *routes = load_routes(argv[1]); check(routes != NULL , "your route file has an errro."); while(1){ url = read_line("URL>"); check_debug(url != NULL , "goodbye"); route = match_url(routes , url); if(route) { printf("match %s == %s\n" , bdata(url) , bdata(route)); } else{ printf("fail;%s \n" , bdata(url)); } bdestroy(url); } destroy_routes(routes); return 0; error: destroy_routes(routes); return 1; }
int connection_route_request(Connection *conn) { Host *host = NULL; Route *route = NULL; bstring path = Request_path(conn->req); check_debug(path != NULL, "No path given, in request, ignoring."); Server *server = Server_queue_latest(); check(server != NULL, "No server in the server queue, tell Zed."); if(conn->req->host_name) { host = Server_match_backend(server, conn->req->host_name); } else { host = server->default_host; } error_unless(host, conn, 404, "Request for a host we don't have registered: %s", bdata(conn->req->host_name)); Backend *found = Host_match_backend(host, path, &route); error_unless(found, conn, 404, "Handler not found: %s", bdata(path)); Request_set_action(conn->req, found); conn->req->target_host = host; conn->req->pattern = route->pattern; conn->req->prefix = route->prefix; return Connection_backend_event(found, conn); error: return CLOSE; }
int test_check_debug() { int i = 0; check_debug(i != 0, "Oops, I was 0."); return 0; error: return -1; }
/** Functions for loading * Loading database -> opening file and allocation of whole database into * memory with handlers for errors. */ int Database_load(struct Connection *conn) { int rc = fread(conn->db, sizeof(struct Database), 1, conn->file); check_debug(!rc, "Failed to load database"); return 0; error: return -1; }
int Dir_serve_file(Dir *dir, Request *req, Connection *conn) { FileRecord *file = NULL; bstring resp = NULL; bstring path = Request_path(req); bstring pattern = req->pattern; int rc = 0; int is_get = biseq(req->request_method, &HTTP_GET); int is_head = is_get ? 0 : biseq(req->request_method, &HTTP_HEAD); check(path, "Request had not path. That's weird."); req->response_size = 0; if(!(is_get || is_head)) { req->status_code = 405; rc = Response_send_status(conn, &HTTP_405); check_debug(rc == blength(&HTTP_405), "Failed to send 405 to client."); return -1; } else { file = Dir_resolve_file(dir, pattern, path); resp = Dir_calculate_response(req, file); if(resp) { rc = Response_send_status(conn, resp); check_debug(rc == blength(resp), "Failed to send error response on file serving."); } else if(is_get) { rc = Dir_stream_file(file, conn); req->response_size = rc; check_debug(rc == file->sb.st_size, "Didn't send all of the file, sent %d of %s.", rc, bdata(path)); } else if(is_head) { rc = Dir_send_header(file, conn); check_debug(rc, "Failed to write header to socket."); } else { sentinel("How the hell did you get to here. Tell Zed."); } FileRecord_release(file); return 0; } sentinel("Invalid code branch, Tell Zed you have magic."); error: FileRecord_release(file); return -1; }
int dl_count(list_t *list){ check_debug(list != NULL, "List is NULL."); check_debug(list->prev != NULL && list->next != NULL, "List is empty."); list_t *node = NULL; node = list->next; int count = 0; for(; node != list; node = node->next){ check_debug(node != NULL && node->next != NULL, "Invalid list, node: %s, node->next: %s", node == NULL ? "NULL" : "VALID", node->next == NULL ? "NULL" : "VALID"); count++; } return count; error: return 0; }
int fs_create_dir(const char *path) { errno = 0; mkdir(path, S_IRWXU); check_debug(errno == 0, "Could not create dir"); return 0; error: return errno; }
int test_check_debug() { int i = 0; check_debug(i != 0, "It was 0"); return 0; error: return -1; }
static ssize_t ssl_stream_file(IOBuf *iob, int fd, off_t len) { ssize_t sent = 0; off_t total = 0; ssize_t amt = 0; ssize_t tosend = 0; int conn_fd = IOBuf_fd(iob); char buff[1024]; for(total = 0; fdwait(conn_fd, 'w') == 0 && total < len; total += tosend) { tosend = pread(fd, buff, sizeof(buff), total); check_debug(tosend > 0, "Came up short in reading file %d\n", fd); // We do this in case the file somehow lengthened on us. In general, // it shouldn't happen. if(tosend + total > len) tosend = len - total; sent = 0; while(sent < tosend) { amt = ssl_send(iob, buff, tosend); check_debug(amt > 0, "ssl_send failed in ssl_stream_file with " "return code %zd", amt); sent += amt; } check(Register_write(iob->fd, sent) != -1, "Failed to record write, must have died."); } check(total <= len, "Wrote way too much, wrote %d but size was %zd", (int)total, len); check(total == len, "Sent other than expected, sent: %d, but expected: %zd", (int)total, len); return total; error: return -1; }