void send_format(const char *fmt, ...) { static char buf[513]; va_list ap; va_start(ap, fmt); if (vsnprintf(buf, sizeof(buf)-1, fmt, ap) == sizeof(buf)-1) buf[sizeof(buf)-1] = '\0'; va_end(ap); send_raw(buf); }
/** * Sends a frame on the network. * Returns false if the socket has closed or the write failed for some other reason */ bool send_frame(int sock, const addr_t &target, nw_cmd_t cmd, nw_var_t * vars) { char * nw = (char*)malloc(FRAME_SIZE+1); int pos = HASH_SIZE; uint16_t nwi16; uint32_t nwi32; /** * Select protocol cmd and write cmd to first pos */ if(protocol[cmd].cmd != cmd) fprintf(stderr, "WARNING: Protocol cmd #%d does not match value in frame_t struct\n",cmd); const int num_vars = protocol[cmd].num_vars; const nw_var_type_t * var_types = protocol[cmd].var_types; nw[pos] = cmd; pos+=sizeof(char); for(int i=0; i < num_vars; ++i) { switch(var_types[i]) { case NW_VAR_FLOAT: pos += ftnw(vars[i].f,nw+pos); break; case NW_VAR_UINT16: nwi16 = htons((uint16_t)vars[i].i); memcpy(nw+pos,&nwi16,sizeof(uint16_t)); pos += sizeof(uint16_t); break; case NW_VAR_UINT32: nwi32 = htonl(vars[i].i); memcpy(nw+pos,&nwi32,sizeof(uint32_t)); pos += sizeof(uint32_t); break; case NW_VAR_CHAR: nw[pos] = vars[i].c; pos += sizeof(char); break; case NW_VAR_STR: pos += strtnw(vars[i].str, nw+pos); break; } if(pos >= FRAME_SIZE) { fprintf(stderr, "Network frames are to small!\n"); exit(2); } } char hash[41]; get_hash(hash,nw+HASH_SIZE,PAYLOAD_SIZE); memcpy(nw,hash,HASH_SIZE); bool ret = send_raw(sock, nw, target); free(nw); return ret; }
void send_words(const char *first, ...) { char buf[513]; struct manyargs arg; char *word; va_list ap; va_start(ap, first); arg.c = 0; arg.v[arg.c++] = (char *)first; while ((word = va_arg(ap, char *))) arg.v[arg.c++] = word; va_end(ap); rfc_join(buf, sizeof(buf), arg.c, arg.v); send_raw(buf); }
void *thread (void *arg) { int i; char *buf = NULL; if (bufsize > 0) buf = xzmalloc (bufsize); for (i = 0; i < iter; i++) { if (vopt) log_msg ("sending %d of %d", i + 1, iter); if (raw) send_raw (buf, bufsize); else send_czmq (buf, bufsize); } if (buf) free (buf); return NULL; }
int main (void) { /* temperature 26 ^C */ char data[6] = {0xb2,0x4d,0x1F,0xE0,0xD8,0x27}; if (wiringPiSetupGpio() == -1) return 1; if (timer_init()) return 1; printf ("Raspberry Pi IR encode program....\n") ; pinMode (26, OUTPUT) ; while (1) { output_init(); #if 1 send_raw(rawCodes_ac_open, sizeof(rawCodes_ac_open)/sizeof(int)); #else send_data(data, 6); send_data(data, 6); #endif pinMode(PWM_PIN,OUTPUT); delay_us(100000); } printf("end of program \n"); output_38k_off(); //pinMode(PWM_PIN,OUTPUT); }
/* connect: connect to IRC */ bool TwitchBot::connect() { char buf[MAX_MSG]; if (!(bot_connected = !cconnect(&client, TWITCH_SERV, TWITCH_PORT))) return false; /* send required IRC data: PASS, NICK, USER */ snprintf(buf, MAX_MSG, "PASS %s", bot_password); send_raw(&client, buf); snprintf(buf, MAX_MSG, "NICK %s", bot_name); send_raw(&client, buf); snprintf(buf, MAX_MSG, "USER %s", bot_name); send_raw(&client, buf); /* enable tags in PRIVMSGs */ snprintf(buf, MAX_MSG, "CAP REQ :twitch.tv/tags"); send_raw(&client, buf); /* receive join and part information */ snprintf(buf, MAX_MSG, "CAP REQ :twitch.tv/membership"); send_raw(&client, buf); /* allow access to additional twitch commands */ snprintf(buf, MAX_MSG, "CAP REQ :twitch.tv/commands"); send_raw(&client, buf); if (strlen(bot_channel) > 32) { fprintf(stderr, "error: channel name too long\n"); disconnect(); return false; } /* join channel */ snprintf(buf, MAX_MSG, "JOIN %s", bot_channel); send_raw(&client, buf); tick_thread = std::thread(&TwitchBot::tick, this); init_timers(bot_channel + 1, bot_token, CID); return true; }
void usb_midi_class::sendNoteOn(uint8_t note, uint8_t velocity, uint8_t channel) { send_raw(0x09, 0x90 | ((channel - 1) & 0x0F), note & 0x7F, velocity & 0x7F); }
static void lwp_write_int64(int afdt_fd, int64_t d) { send_raw(afdt_fd, &d, sizeof(d)); }
static void lwp_write(int afdt_fd, const std::string &buf) { size_t len = buf.length(); send_raw(afdt_fd, &len, sizeof(len)); send_raw(afdt_fd, buf.c_str(), len); }
int main(int argc, char** argv){ int ret = send_raw("hola", 4, "127.0.0.1", 54269); printf("sent %d bytes\n", ret); }
void smtp_client::connection::send_line(std::string line) { send_raw(line + "\r\n"); }
void smtp_client::connection::got_response(std::string resp, boost::system::error_code ec, size_t bytes) { if (ec) { NSC_LOG_ERROR("smtp failure in reading: " + ec.message()); boost::lock_guard<boost::mutex> lg(sc->m); if (cur) sc->ready.push_back(cur); sc->active_connection.reset(); return; } std::string line; line.reserve(bytes); for (size_t i = 0; i < bytes; i++) line += char(readbuf.sbumpc()); resp += line; if (line.length() >= 4 && line[3] == '-') { boost::asio::async_read_until(serv, readbuf, "\r\n", boost::bind(&connection::got_response, shared_from_this(), resp, _1, _2)); return; } NSC_DEBUG_MSG("smtp read " + resp); bool broken_resp = resp.empty() || !('2' <= resp[0] && resp[0] <= '5') || (resp[0] == '3' && (state != DATA || resp.substr(0,3) != "354")); // FIXME deferral / drop-on-the-floor notifications if (broken_resp || resp[0] == '4') { boost::lock_guard<boost::mutex> lg(sc->m); if (cur) sc->deferred.push_back(cur); } if (broken_resp || state == QUIT) { NSC_LOG_ERROR("smtp terminating"); boost::lock_guard<boost::mutex> lg(sc->m); sc->active_connection.reset(); return; } if ((resp[0] == '4' || resp[0] == '5' || state == DATA_354) && (resp.substr(0,3) != "502" || state != EHLO)) { cur.reset(); if (sc->ready.empty() || state <= RSET) { state = QUIT; send_line("QUIT"); } else { state = RSET; send_line("RSET"); } return; } assert(!resp.empty()); switch (state) { case BANNER: assert(resp[0] == '2'); state = EHLO; send_line("EHLO " + config["canonical-name"]); break; case EHLO: if (resp.substr(0,3) == "502") { state = HELO; send_line("HELO" + config["canonical-name"]); break; } assert(resp[0] == '2'); /* passthrough */ case HELO: case RSET: assert(resp[0] == '2'); assert(!cur); { boost::lock_guard<boost::mutex> lg(sc->m); if (sc->ready.empty()) { state = QUIT; send_line("QUIT"); break; } cur = sc->ready.front(); sc->ready.pop_front(); } assert(cur); state = MAIL_FROM; send_line("MAIL FROM: <" + cur->sender + ">"); break; case MAIL_FROM: assert(resp[0] == '2'); assert(cur); state = RCPT_TO; send_line("RCPT TO: <" + cur->recipient + ">"); break; case RCPT_TO: assert(resp[0] == '2'); assert(cur); state = DATA; send_line("DATA"); break; case DATA: assert(resp.substr(0,3) == "354"); assert(cur); state = DATA_354; send_raw(cur->data + ".\r\n"); break; case DATA_354: case QUIT: assert(0); // handled above break; } }
void send_string(char* ip, int port, char* string, int size, char flags){ char buffer[size+1]; buffer[0] = flags; strncpy(buffer+1, string, size); send_raw(ip, port, buffer, size+1); }
void usb_midi_class::sendControlChange(uint8_t control, uint8_t value, uint8_t channel) { send_raw(0x0B, 0xB0 | ((channel - 1) & 0x0F), control & 0x7F, value & 0x7F); }
void usb_midi_class::sendPolyPressure(uint8_t note, uint8_t pressure, uint8_t channel) { send_raw(0x0A, 0xA0 | ((channel - 1) & 0x0F), note & 0x7F, pressure & 0x7F); }
void usb_midi_class::sendProgramChange(uint8_t program, uint8_t channel) { send_raw(0x0C, 0xC0 | ((channel - 1) & 0x0F), program & 0x7F, 0); }
void usb_midi_class::sendAfterTouch(uint8_t pressure, uint8_t channel) { send_raw(0x0D, 0xD0 | ((channel - 1) & 0x0F), pressure & 0x7F, 0); }