bool mct(t_cli *c, t_msg *msg) { int64_t x; int64_t y; int64_t xmax; int64_t ymax; t_list *params; (void)msg; x = 0; y = 0; xmax = c->servptr->map.width; ymax = c->servptr->map.height; if ((params = new_list()) == NULL || init_list(params) == false) return (ERR(RED"Omg malloc failed, BAIL OUT BAIL OUT\n"WHITE), false); while (y <= xmax) { while (x <= ymax) { prepare_message(params, x, y); bct(c, &(t_msg){NULL, "bct", params, 0}); x++; } x = 0; y++; } return (list_destruct(¶ms, &free), true); }
void log_entry(LogLevel level, char *format, ...) { if (level > CURRENT_LEVEL) { return; } va_list ap; va_start(ap, format); char *message = prepare_message(format, ap); va_end(ap); switch (level) { case LogCritical: case LogNormal: case LogVerbose: write_console_log_entry(message); write_file_log_entry(message); break; case LogDebug: write_file_log_entry(message); break; } free(message); }
BOOST_FIXTURE_TEST_CASE(test_connection_closed_when_illegal_message, F) { int ret = alloc_websocket_peer(connection); BOOST_REQUIRE_MESSAGE(ret == 0, "alloc_websocket_peer did not return 0"); struct websocket *socket = (struct websocket *)connection->parser.data; socket->upgrade_complete = true; uint8_t mask[4] = {0xaa, 0x55, 0xcc, 0x11}; prepare_message(WS_OPCODE_ILLEGAL, NULL, 0, true, mask); ws_get_header(socket, read_buffer_ptr++, read_buffer_length); BOOST_CHECK_MESSAGE(num_close_called == 1, "Close of buffered_reader was not called when receiving an illegal frame!"); BOOST_CHECK_MESSAGE(is_close_frame(WS_CLOSE_UNSUPPORTED), "No close frame sent when receiving an illegal frame!"); }
void print_string(const char *string, int num_lines, int freq_min, int freq_max, int col_time_ms) { Context context; Pa_Initialize(); context_init(&context, num_lines, freq_min, freq_max, col_time_ms); start_playback(&context); int num_cols = 0; const char *message = prepare_message(string, &num_cols); for (int col = 0; col < num_cols; col++) { const char *col_start = message + col*ROWS_PER_LETTER; print_text_column(&context, col_start, ROWS_PER_LETTER); } free((void*)message); stop_playback(&context); Pa_Terminate(); context_dealloc(&context); }
/* Prepare DHCPv4 Message request and send it to peer */ static void send_request(struct net_if *iface, bool renewal) { struct net_buf *buf; buf = prepare_message(iface, DHCPV4_MSG_TYPE_REQUEST); if (!buf) { goto fail; } if (!add_server_id(buf) || !add_req_ipaddr(buf) || !add_end(buf)) { goto fail; } setup_header(buf); if (net_send_data(buf) < 0) { goto fail; } if (renewal) { iface->dhcpv4.state = NET_DHCPV4_RENEWAL; } else { iface->dhcpv4.state = NET_DHCPV4_REQUEST; } iface->dhcpv4.attempts++; k_delayed_work_init(&iface->dhcpv4_timeout, dhcpv4_timeout); k_delayed_work_submit(&iface->dhcpv4_timeout, get_dhcpv4_timeout()); return; fail: NET_DBG("Message preparation failed"); if (!buf) { net_nbuf_unref(buf); } }
/* Prepare DHCPv4 Discover message and broadcast it */ static void send_discover(struct net_if *iface) { struct net_buf *buf; iface->dhcpv4.xid++; buf = prepare_message(iface, DHCPV4_MSG_TYPE_DISCOVER); if (!buf) { goto fail; } if (!add_req_options(buf) || !add_end(buf)) { goto fail; } setup_header(buf); if (net_send_data(buf) < 0) { goto fail; } iface->dhcpv4.state = NET_DHCPV4_DISCOVER; k_delayed_work_init(&iface->dhcpv4_timeout, dhcpv4_timeout); k_delayed_work_submit(&iface->dhcpv4_timeout, get_dhcpv4_timeout()); return; fail: NET_DBG("Message preparation failed"); if (!buf) { net_nbuf_unref(buf); } }
/* * The entry point in C. * * The bootstrap routine has to load the kickstart at 0x01000000, with RO sections growing up the memory and * RW sections stored beneath the 0x01000000 address. It is supposed to transfer the GRUB information further * into the 64-bit kickstart. * * The kickstart is assembled from modules which have been loaded by GRUB. The modules may be loaded separately, * or as a collection in PKG file. If some file is specified in both PKG file and list of separate modules, the * copy in PKG will be skipped. */ static void __bootstrap(unsigned int magic, void *mb) { struct mb_mmap *mmap = NULL; unsigned long len = 0; unsigned long ro_size = 0; unsigned long rw_size = 0; unsigned long ksize; unsigned long mod_end = 0; unsigned long kbase = 0; unsigned long kstart = 0; void *kend = NULL; kernel_entry_fun_t kentry = NULL; struct ELF_ModuleInfo *kdebug = NULL; #ifdef DEBUG_MEM struct mb_mmap *mm2; #endif /* * This will set fb_Mirror address to start of our working memory. * We don't know its size yet, we will allocate it later. */ fb_Mirror = __bs_malloc(0); #ifdef MULTIBOOT_64BIT /* * tell the CPU that we will support SSE. We do it here because x86-64 compiler * with -m32 switch will use SSE for operations on long longs. */ wrcr(cr4, rdcr(cr4) | (3 << 9)); /* Clear the EM and MP flags of CR0 */ wrcr(cr0, rdcr(cr0) & ~6); #endif switch(magic) { case MB_STARTUP_MAGIC: /* Parse multiboot v1 information */ mod_end = mb1_parse(mb, &mmap, &len); break; case MB2_STARTUP_MAGIC: /* Parse multiboot v2 information */ mod_end = mb2_parse(mb, &mmap, &len); break; default: /* What to do here? We have no console... Die silently... */ return; } #ifdef DEBUG_MEM ksize = len; mm2 = mmap; kprintf("[BOOT] Memory map contents:\n", mmap); while (ksize >= sizeof(struct mb_mmap)) { #ifdef DEBUG_MEM_TYPE if (mm2->type == DEBUG_MEM_TYPE) #endif kprintf("[BOOT] Type %lu addr %p len %p\n", mm2->type, mm2->addr, mm2->len); ksize -= mm2->size+4; mm2 = (struct mb_mmap *)(mm2->size + (unsigned long)mm2 + 4); } #endif D(kprintf("[BOOT] Modules end at 0x%p\n", mod_end)); if (!firstMod) { panic("No kickstart modules found, nothing to run"); } tag->ti_Tag = KRN_MMAPAddress; tag->ti_Data = KERNEL_OFFSET | (unsigned long)mmap; tag++; tag->ti_Tag = KRN_MMAPLength; tag->ti_Data = len; tag++; /* Setup stage - prepare the environment */ setup_mmu(); /* Count kickstart size */ if (!GetKernelSize(firstMod, &ro_size, &rw_size, NULL)) { panic("Failed to determine kickstart size"); } D(kprintf("[BOOT] Code %u, data %u\n", ro_size, rw_size)); /* * Total kickstart size + alignment window (page size - 1) + some free space (512KB) for * boot-time memory allocator. * TODO: This is a temporary thing. Currently our kernel expects that it can use addresses beyond * KRN_KernelHighest to store boot-time private data, supervisor stack, segment descriptors, MMU stuff, etc. * The area is joined with read-only section because it's accessed only by supervisor-mode code * and can safely be marked as read-only for users. * Boot-time allocator needs to be smarter. */ ksize = ro_size + rw_size + PAGE_SIZE - 1 + 0x80000; /* Now locate the highest appropriate region */ while (len >= sizeof(struct mb_mmap)) { if (mmap->type == MMAP_TYPE_RAM) { unsigned long long start = mmap->addr; unsigned long long end = mmap->addr + mmap->len; /* * The region must be located in 32-bit memory and must not overlap * our modules. * Here we assume the following: * 1. Multiboot data from GRUB is placed in low memory. * 2. At least one module is placed in upper memory, above ourselves. * 3. There's no usable space below our modules. */ if ((start <= 0x100000000ULL - ksize) && (end >= mod_end + ksize)) { unsigned long size; if (start < mod_end) start = mod_end; if (end > 0x100000000ULL) end = 0x100000000ULL; /* Remember the region if it fits in */ size = end - start; if (size >= ksize) { /* * We place .data section at the start of the region, followed by .code section * at page-aligned 'kbase' address. * There must be a space beyond kickstart's read-only section, because the kickstart * will extend it in order to store boot-time configuration and own private data. */ kstart = start; kbase = start + rw_size; kbase = (kbase + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1); } } } len -= mmap->size+4; mmap = (struct mb_mmap *)(mmap->size + (unsigned long)mmap+4); } if (!kbase) { panic("Failed to find %u bytes for the kickstart.\n" "Your system doesn't have enough memory."); } kprintf("[BOOT] Loading kickstart, data 0x%p, code 0x%p...\n", kstart, kbase); if (!LoadKernel(firstMod, (void *)kbase, (void *)kstart, (char *)__bss_track, DEF_SYSBASE, &kend, &kentry, &kdebug)) { panic("Failed to load the kickstart"); } /* Prepare the rest of boot taglist */ prepare_message(kstart, kbase, kend, kdebug); #ifdef DEBUG_TAGLIST kprintf("[BOOT] Boot taglist:\n"); for (tag = km; tag->ti_Tag != TAG_DONE; tag++) kprintf("[BOOT] 0x%llp 0x%llp\n", tag->ti_Tag, tag->ti_Data); #endif /* Jump to the kickstart */ kick(kentry, km); panic("Failed to run the kickstart"); }
static void prepare_message_string(uint8_t type, const char *message, bool shall_mask, uint8_t mask[4]) { prepare_message(type, (uint8_t *)message, ::strlen(message), shall_mask, mask); }
void net_process() { while (true) { struct bitcoin_msg_header header; if (read_all(sock, (char*)&header, sizeof(header)) != sizeof(header)) return disconnect("failed to read message header"); if (header.magic != BITCOIN_MAGIC) return disconnect("invalid magic bytes"); struct timeval start_read; gettimeofday(&start_read, NULL); header.length = le32toh(header.length); if (header.length > 5000000) return disconnect("got message too large"); auto msg = std::make_shared<std::vector<unsigned char> > (sizeof(struct bitcoin_msg_header) + uint32_t(header.length)); if (read_all(sock, (char*)&(*msg)[sizeof(struct bitcoin_msg_header)], header.length) != int(header.length)) return disconnect("failed to read message"); unsigned char fullhash[32]; CSHA256 hash; hash.Write(&(*msg)[sizeof(struct bitcoin_msg_header)], header.length).Finalize(fullhash); hash.Reset().Write(fullhash, sizeof(fullhash)).Finalize(fullhash); if (memcmp((char*)fullhash, header.checksum, sizeof(header.checksum))) return disconnect("got invalid message checksum"); if (!strncmp(header.command, "version", strlen("version"))) { if (connected != 0) return disconnect("got invalid version"); connected = 1; if (header.length < sizeof(struct bitcoin_version_start)) return disconnect("got short version"); struct bitcoin_version_start *their_version = (struct bitcoin_version_start*) &(*msg)[sizeof(struct bitcoin_msg_header)]; printf("%s Protocol version %u\n", host.c_str(), le32toh(their_version->protocol_version)); struct bitcoin_version_with_header version_msg; version_msg.version.start.timestamp = htole64(time(0)); memcpy(((char*)&version_msg.version.end.user_agent) + 27, location, 7); static_assert(BITCOIN_UA_LENGTH == 27 + 7 + 2 /* 27 + 7 + '/' + '\0' */, "BITCOIN_UA changed in header but file not updated"); prepare_message("version", (unsigned char*)&version_msg, sizeof(struct bitcoin_version)); if (send_all(sock, (char*)&version_msg, sizeof(struct bitcoin_version_with_header)) != sizeof(struct bitcoin_version_with_header)) return disconnect("failed to send version message"); struct bitcoin_msg_header verack_header; prepare_message("verack", (unsigned char*)&verack_header, 0); if (send_all(sock, (char*)&verack_header, sizeof(struct bitcoin_msg_header)) != sizeof(struct bitcoin_msg_header)) return disconnect("failed to send verack"); continue; } else if (!strncmp(header.command, "verack", strlen("verack"))) { if (connected != 1) return disconnect("got invalid verack"); connected = 2; send_mutex.unlock(); continue; } if (connected != 2) return disconnect("got non-version, non-verack before version+verack"); if (!strncmp(header.command, "ping", strlen("ping"))) { memcpy(&header.command, "pong", sizeof("pong")); memcpy(&(*msg)[0], &header, sizeof(struct bitcoin_msg_header)); std::lock_guard<std::mutex> lock(send_mutex); if (send_all(sock, (char*)&(*msg)[0], sizeof(struct bitcoin_msg_header) + header.length) != int64_t(sizeof(struct bitcoin_msg_header) + header.length)) return disconnect("failed to send pong"); continue; } else if (!strncmp(header.command, "inv", strlen("inv"))) { std::lock_guard<std::mutex> lock(send_mutex); try { std::set<std::vector<unsigned char> > setRequestBlocks; std::set<std::vector<unsigned char> > setRequestTxn; std::vector<unsigned char>::const_iterator it = msg->begin(); it += sizeof(struct bitcoin_msg_header); uint64_t count = read_varint(it, msg->end()); if (count > 50000) return disconnect("inv count > MAX_INV_SZ"); uint32_t MSG_TX = htole32(1); uint32_t MSG_BLOCK = htole32(2); for (uint64_t i = 0; i < count; i++) { move_forward(it, 4 + 32, msg->end()); std::vector<unsigned char> hash(it-32, it); const uint32_t type = (*(it-(1+32)) << 24) | (*(it-(2+32)) << 16) | (*(it-(3+32)) << 8) | *(it-(4+32)); if (type == MSG_TX) { if (!txnAlreadySeen.insert(hash).second) continue; setRequestTxn.insert(hash); } else if (type == MSG_BLOCK) { if (!blocksAlreadySeen.insert(hash).second) continue; setRequestBlocks.insert(hash); } else return disconnect("unknown inv type"); } if (setRequestBlocks.size()) { std::vector<unsigned char> getdataMsg; std::vector<unsigned char> invCount = varint(setRequestBlocks.size()); getdataMsg.reserve(sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestBlocks.size()*36); getdataMsg.insert(getdataMsg.end(), sizeof(struct bitcoin_msg_header), 0); getdataMsg.insert(getdataMsg.end(), invCount.begin(), invCount.end()); for (auto& hash : setRequestBlocks) { getdataMsg.insert(getdataMsg.end(), (unsigned char*)&MSG_BLOCK, ((unsigned char*)&MSG_BLOCK) + 4); getdataMsg.insert(getdataMsg.end(), hash.begin(), hash.end()); } prepare_message("getdata", (unsigned char*)&getdataMsg[0], invCount.size() + setRequestBlocks.size()*36); if (send_all(sock, (char*)&getdataMsg[0], sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestBlocks.size()*36) != int(sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestBlocks.size()*36)) return disconnect("error sending getdata"); for (auto& hash : setRequestBlocks) { struct timeval tv; gettimeofday(&tv, NULL); for (unsigned int i = 0; i < hash.size(); i++) printf("%02x", hash[hash.size() - i - 1]); printf(" requested from %s at %lu\n", host.c_str(), uint64_t(tv.tv_sec) * 1000 + uint64_t(tv.tv_usec) / 1000); } } if (setRequestTxn.size()) { std::vector<unsigned char> getdataMsg; std::vector<unsigned char> invCount = varint(setRequestTxn.size()); getdataMsg.reserve(sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestTxn.size()*36); getdataMsg.insert(getdataMsg.end(), sizeof(struct bitcoin_msg_header), 0); getdataMsg.insert(getdataMsg.end(), invCount.begin(), invCount.end()); for (const std::vector<unsigned char>& hash : setRequestTxn) { getdataMsg.insert(getdataMsg.end(), (unsigned char*)&MSG_TX, ((unsigned char*)&MSG_TX) + 4); getdataMsg.insert(getdataMsg.end(), hash.begin(), hash.end()); } prepare_message("getdata", (unsigned char*)&getdataMsg[0], invCount.size() + setRequestTxn.size()*36); if (send_all(sock, (char*)&getdataMsg[0], sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestTxn.size()*36) != int(sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestTxn.size()*36)) return disconnect("error sending getdata"); } } catch (read_exception) { return disconnect("failed to process inv"); } continue; } memcpy(&(*msg)[0], &header, sizeof(struct bitcoin_msg_header)); if (!strncmp(header.command, "block", strlen("block"))) { provide_block(this, msg, start_read); } else if (!strncmp(header.command, "tx", strlen("tx"))) { provide_transaction(this, msg); } } }