int mrp_get_domain(struct mrp_listener_ctx *ctx, struct mrp_domain_attr *class_a, struct mrp_domain_attr *class_b) { char *msgbuf; int ret; /* we may not get a notification if we are joining late, * so query for what is already there ... */ msgbuf = malloc(1500); if (NULL == msgbuf) return -1; memset(msgbuf, 0, 1500); sprintf(msgbuf, "S??"); ret = send_msg(msgbuf, 1500, ctx); free(msgbuf); if (ret != 1500) return -1; while (!ctx->halt_tx && (ctx->domain_a_valid == 0) && (ctx->domain_b_valid == 0)) usleep(20000); class_a->id = 0; class_a->priority = 0; class_a->vid = 0; class_b->id = 0; class_b->priority = 0; class_b->vid = 0; if (ctx->domain_a_valid) { class_a->id = ctx->domain_class_a_id; class_a->priority = ctx->domain_class_a_priority; class_a->vid = ctx->domain_class_a_vid; } if (ctx->domain_b_valid) { class_b->id = ctx->domain_class_b_id; class_b->priority = ctx->domain_class_b_priority; class_b->vid = ctx->domain_class_b_vid; } return 0; }
/* Send a request to get the slave ID of the device (only available in serial communication). */ int modbus_report_slave_id(modbus_t *ctx, uint8_t *dest) { int rc; int req_length; uint8_t req[_MIN_REQ_LENGTH]; req_length = ctx->backend->build_request_basis(ctx, _FC_REPORT_SLAVE_ID, 0, 0, req); /* HACKISH, addr and count are not used */ req_length -= 4; rc = send_msg(ctx, req, req_length); if (rc > 0) { int i; int offset; uint8_t rsp[MAX_MESSAGE_LENGTH]; rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION); if (rc == -1) return -1; rc = check_confirmation(ctx, req, rsp, rc); if (rc == -1) return -1; offset = ctx->backend->header_length + 2; /* Byte count, slave id, run indicator status, additional data */ for (i=0; i < rc; i++) { dest[i] = rsp[offset + i]; } } return rc; }
static void test_ctx_send_cb(struct pomp_ctx *ctx, struct pomp_conn *conn, struct pomp_buffer *buf, uint32_t status, void *cookie, void *userdata) { int res = 0; struct test_data *data = userdata; struct test_peer *src = NULL; struct test_peer *dst = NULL; CU_ASSERT_PTR_NOT_NULL(ctx); CU_ASSERT_PTR_NOT_NULL(conn); CU_ASSERT_PTR_NOT_NULL(buf); data->sendcount++; CU_ASSERT_PTR_NULL(cookie); /* Internal function invalid arguments checks */ res = pomp_ctx_notify_send(NULL, conn, buf, 0); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_notify_send(ctx, NULL, buf, 0); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_notify_send(ctx, conn, NULL, 0); CU_ASSERT_EQUAL(res, -EINVAL); /* Get source and destination */ src = (ctx == data->srv.ctx) ? &data->srv : &data->cli; dst = (ctx == data->srv.ctx) ? &data->cli : &data->srv; if (src->recurs_send_enabled) { /* Disable recursive send. */ src->recurs_send_enabled = 0; /* Exchange some message */ send_msg(data, src, dst, "recursive_msg"); } }
int main() { uint16_t num_trackers; in_addr_t trackers[MAX_TRACKERS]; uint16_t maxpeers; uint16_t num_pkg_servers; in_addr_t pkg_servers[MAX_PKG_SERVERS]; int i; int sockfd; char trackers_url[256]; char pkg_servers_url[256]; sprintf(trackers_url,"127.0.0.1"); sprintf(pkg_servers_url,"127.0.0.1"); fprintf(stderr, "main:trackers_url (%s)\n", trackers_url); fprintf(stderr, "main:pkg_servers_url (%s)\n", pkg_servers_url); if (init(&num_trackers, trackers_url, trackers, &maxpeers, pkg_servers_url, &num_pkg_servers, pkg_servers) != 0) { fprintf(stderr, "main:init failed\n"); return(-1); } if ((sockfd = init_tracker_comm(0)) < 0) { fprintf(stderr, "main:init_tracker_comm failed\n"); return(-1); } for (i = 0 ; i < num_trackers; ++i) { send_msg(sockfd, &trackers[i], DUMP_TABLES); } return(0); }
static int on_host_init(VSCMsgHeader *mhHeader, VSCMsgInit *incoming) { uint32_t *capabilities = (incoming->capabilities); int num_capabilities = 1 + ((mhHeader->length - sizeof(VSCMsgInit)) / sizeof(uint32_t)); int i; int rv; pthread_t thread_id; incoming->version = ntohl(incoming->version); if (incoming->version != VSCARD_VERSION) { if (verbose > 0) { printf("warning: host has version %d, we have %d\n", verbose, VSCARD_VERSION); } } if (incoming->magic != VSCARD_MAGIC) { printf("unexpected magic: got %d, expected %d\n", incoming->magic, VSCARD_MAGIC); return -1; } for (i = 0 ; i < num_capabilities; ++i) { capabilities[i] = ntohl(capabilities[i]); } /* Future: check capabilities */ /* remove whatever reader might be left in qemu, * in case of an unclean previous exit. */ send_msg(VSC_ReaderRemove, VSCARD_MINIMAL_READER_ID, NULL, 0); /* launch the event_thread. This will trigger reader adds for all the * existing readers */ rv = pthread_create(&thread_id, NULL, event_thread, NULL); if (rv < 0) { perror("pthread_create"); return rv; } return 0; }
int ACE_TMAIN (int, ACE_TCHAR *[]) { long pid = long (ACE_OS::getpid ()); ACE_Typed_SV_Message_Queue<Message_Data> msgque (key_t (SRV_KEY)); Message_Data msg_data (pid, ACE_OS::cuserid (static_cast<char *> (0)), "did you get this?"); ACE_Typed_SV_Message<Message_Data> send_msg (msg_data, SRV_ID, msg_data.length ()), recv_msg (pid); if (msgque.send (send_msg) < 0) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("msgque.send")), 1); if (msgque.recv (recv_msg) < 0) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("msgque.recv")), 1); Message_Data &recv_msg_data = recv_msg.data (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("a message of length %d") ACE_TEXT (" received from server %d") ACE_TEXT (" (user %C): %C\n"), recv_msg_data.length (), recv_msg_data.pid (), recv_msg_data.user (), recv_msg_data.text ())); return 0; }
int init_draw_graph_u(sym_environment *env) { if (env->par.do_draw_graph){ /*start up the graphics window*/ int s_bufid; if (env->par.dg_machine_set){ spawn(env->par.dg_exe, (char **)NULL, env->par.dg_debug | TaskHost, env->par.dg_machine, 1, &env->dg_tid); }else{ spawn(env->par.dg_exe, (char **)NULL, env->par.dg_debug, (char *)NULL, 1, &env->dg_tid); } s_bufid = init_send(DataInPlace); send_char_array((char *)&env->par.dg_par, sizeof(dg_params)); send_msg(env->dg_tid, DG_DATA); freebuf(s_bufid); #ifdef USE_SYM_APPLICATION if (env->dg_tid) CALL_USER_FUNCTION( user_init_draw_graph(env->user, env->dg_tid) ); #endif } return(FUNCTION_TERMINATED_NORMALLY); }
bool gdbr_kill_pid(libgdbr_t *g, int pid) { char *cmd; int ret; size_t buffer_size; if (!g || !g->sock || !g->stub_features.multiprocess) { return false; } reg_cache.valid = false; g->stop_reason.is_valid = false; buffer_size = strlen (CMD_KILL_MP) + (sizeof (pid) * 2) + 1; cmd = calloc (buffer_size, sizeof (char)); if (!cmd) { return false; } if ((snprintf (cmd, buffer_size, "%s%x", CMD_KILL_MP, g->pid)) < 0) { free(cmd); return false; } ret = send_msg (g, cmd); free(cmd); if (ret < 0) { return false; } read_packet (g, false); if ((ret = send_ack (g)) < 0) { return false; } if (strncmp (g->data, "OK", 2)) { return false; } return true; }
/* Called from VM Monitor */ int NodeManager_notify_vm_started( char *node_addr, char *vmmon_addr, char *theater ) { int retval = 0; NodeMessage *msg; Dbg_printf( NODE, INFO, "node_addr=%s, vmmon_addr=%s, theater=%s\n", node_addr, vmmon_addr, theater ); msg = node_alloc_msg( NodeMessageID_NOTIFY_VM_STARTED ); node_set_notify_vm_started_msg( msg, vmmon_addr, theater ); if (send_msg( node_addr, NULL, msg ) < 0) { Dbg_printf( NODE, ERROR, "node_send_msg, node_addr=%s, msg=%s failed\n", node_addr, node_msgid2str( msg->msgid ) ); retval = -1; } node_dealloc_msg( msg ); return retval; }
int UnixSocketAdapter::send(const AmSipRequest &req, string &src, string &dst) { if (! isComplete(req)) { ERROR("can not send request: not complete.\n"); return -1; } string rplAddr; string msg; int timeout; if (req.method == "CANCEL") { rplAddr = "/tmp/" + AmSession::getNewId(); msg = serialize_cancel(req, rplAddr); timeout = 50000; /*TODO: WTF's with this value?!*/ } else { rplAddr = src;//AmConfig::ReplySocketName; msg = serialize(req, rplAddr); /* timeout: don't wait for reply [comes through other, * dedicated socket] */ timeout = 0; } return send_msg(msg, rplAddr, dst, timeout); }
int NodeManager_destroy_vm_req( char *node_addr, char *return_cos_addr, char *vm_name ) { int retval = 0; NodeMessage *msg; Dbg_printf( NODE, INFO, "node_addr=%s, return_cos_addr=%s, vm_name=%s\n", node_addr, return_cos_addr, vm_name ); msg = node_alloc_msg( NodeMessageID_DESTROY_VM_REQ ); node_set_destroy_vm_req_msg( msg, vm_name ); if (send_msg( node_addr, return_cos_addr, msg ) < 0) { Dbg_printf( NODE, ERROR, "node_send_msg, node_addr=%s, return_cos_addr=%s, msg=%s failed\n", node_addr, return_cos_addr, node_msgid2str( msg->msgid ) ); retval = -1; } node_dealloc_msg( msg ); return retval; }
/* * Test2b * * Sending thread of test2b */ static void Test2b( void ) { pthread_t t1; char * msg = "Test2b Burst Send Non-Blocking / Receive Blocking"; int recv_count = 0; int send_count = 0; TEST_INTRO( "Send Blocking Test" ); if (pthread_create ( &t1, NULL, &test2b_thread, NULL ) != 0) { printf("Failed to create test2b_thread t1!\n"); FAILURE_EXIT(); } usleep(100000); burst_send( msg, MAX_QUEUE_SIZE, MBX_NON_BLOCKING, NOISY, ON_FAILURE_EXIT ); send_count += MAX_QUEUE_SIZE; usleep(10000); send_msg( msg, MBX_BLOCK, NOISY, ON_FAILURE_EXIT ); send_count += 1; pthread_join( t1, (void*)&recv_count ); printf("Thread 0 sent %d messages\n",send_count); printf("Thread 1 received %d messages\n",recv_count); if (recv_count != send_count) { FAILURE_EXIT(); } TEST_CLOSING(); }
bool campareGameMoney(Hero *hero,long _gameMoney) //判断游戏币是否够用 { Money *money=hero->getMoney(); if (money==NULL) //money类为空 返回false; { return false; } if (_gameMoney<0) //使用的游戏币为负数,返回false { cout<<"jolly:you can increase a negative number money_operator 228"<<endl; return false; } if ((money->money_getGameMoney()-_gameMoney)<0) { msg_error(g_out_buf,1); send_msg(hero->getFd(),g_out_buf); return false; } else { return true; } }
bool increaseGameMoney(Hero *hero,long _gameMoney) //增加游戏币 { Money *money=hero->getMoney(); if (money==NULL) //money类为空 返回false; { return false; } if (_gameMoney<0) //增加的游戏币为负数,返回false { cout<<"jolly:you can increase a negative number money_operator 210"<<endl; return false; } money->money_increaseGameMoney(_gameMoney); money->money_inform(g_out_buf,sizeof(g_out_buf)); send_msg(hero->getFd(),g_out_buf); //发送增加游戏币之后的金币状态 // 增加获得货币写日志功能,jolly 2012 12 17 start char account_msg[1024]={'\0'}; sprintf(account_msg,"%d,%d,%s,%d,%s,%s,%ld,%ld",3,0,server_name,(int)myTime.tv_sec,hero->getIdentity(),hero->getNickName(),money->money_getGameMoney(),_gameMoney); write_log(account_msg); // 增加获得货币写日志功能,jolly 2012 12 17 end return true; }
bool campareGold(Hero *hero,long _gold) //判定元宝是否够用 { Money *money=hero->getMoney(); if (money==NULL) //money类为空 返回false; { return false; } if (_gold<0) //比较的元宝为负数,返回false { cout<<"jolly:you can increase a negative number money_operator 177"<<endl; return false; } if (_gold>money->money_getGold()) //比较的元宝大于了自身的元宝,则提示充值 { snprintf(g_out_buf,sizeof(g_out_buf),"%d,%d,%ld",9,MONEY_NOT_ENOUGH,_gold-money->money_getGold()); send_msg(hero->getFd(),g_out_buf); return false; } else { return true; } }
int client_init(void) { /* if(argc<2) { printf("\n"); printf("sorry,your type is wrong\n"); printf("usage: %s x.x.x.x(server ip)\n",argv[0]); exit(EXIT_FAILURE); } */ if((client_sock = socket(AF_INET, SOCK_DGRAM, 0))< 0) { fprintf(stderr,"%s\n",strerror(errno)) ; exit(EXIT_FAILURE); } else { printf("create socket ok !\n"); } bzero(&server, sizeof(server)); server.sin_family = AF_INET; server.sin_port = htons(SERVER_PORD); server.sin_addr.s_addr = inet_addr("10.1.14.39"); server_len = sizeof(server); send_msg(0,0); return 0; }
void ctrl_g_defence_original() { char buf[200]; if (RINFO.turn==mypos&& (PINFO(mypos).flag & PEOPLE_ALIVE)) { if (PINFO(mypos).flag & PEOPLE_BAD) { if (RINFO.voted[mypos]!=-2) { sprintf (buf, "\33[31m你想崩溃了\33[m"); RINFO.voted[mypos]=-2; } else { sprintf(buf,"\33[31m你不想崩溃了\33[m"); RINFO.voted[mypos]=-1; } } else sprintf(buf,"不能崩溃"); send_msg(mypos,buf); kill_msg(mypos); } }
void mu_signal_process(char *command, int signal) { unsigned short slen; int len, toprocess_id, save_errno; char buff[256]; error_def(ERR_MUPCLIERR); error_def(ERR_MUPIPSIG); slen = sizeof(buff); if (!cli_get_str("ID", buff, &slen)) mupip_exit(ERR_MUPCLIERR); len = slen; toprocess_id = asc2i((uchar_ptr_t)buff, len); if (toprocess_id < 0) { util_out_print("Error converting !AD to a number", FLUSH, len, buff); mupip_exit(ERR_MUPCLIERR); } else { if (-1 == kill(toprocess_id, signal)) { save_errno = errno; util_out_print("Error issuing !AD to process !UL: !AZ", FLUSH, LEN_AND_STR(command), toprocess_id, STRERROR(errno)); } else { util_out_print("!AD issued to process !UL", FLUSH, LEN_AND_STR(command), toprocess_id); if (!MEMCMP_LIT(command, STOP_STR)) { send_msg(VARLSTCNT(9) ERR_MUPIPSIG, 7, LEN_AND_STR(command), signal, process_id, process_id, toprocess_id, toprocess_id); } } } return; }
void soon(int cs) { char buf[1024]; int r; char *home; home = get_pwd(); while ((r = read(cs, buf, 1023)) > 0) { buf[r - 1] = '\0'; ft_printf("received %d bytes: [%s]\n", r, buf); if (!ft_strcmp(buf, "ls")) ft_ls(cs); else if (!ft_strcmp(buf, "pwd")) send_msg(cs, get_pwd(), 0); else if (!ft_strncmp(buf, "cd ", 3) || !ft_strcmp(buf, "cd")) ft_cd(cs, buf, home); else if (!ft_strcmp(buf, "quit")) break ; else send_error(cs, "invalid_cmd"); ft_bzero(buf, 1024); } }
int NodeManager_notify_low_cpu_usage( char *node_addr, char *vmmon_addr, double cpu_usage_history[CPU_USAGE_HISTORY_LEN] ) { int retval = 0; NodeMessage *msg; Dbg_printf( NODE, INFO, "vmmon_addr=%s, cpu_usage_history[0]=%lf\n", vmmon_addr, cpu_usage_history[0] ); msg = node_alloc_msg( NodeMessageID_NOTIFY_LOW_CPU_USAGE ); node_set_notify_cpu_usage_msg( msg, vmmon_addr, cpu_usage_history ); if (send_msg( node_addr, vmmon_addr, msg ) < 0) { Dbg_printf( NODE, ERROR, "send_msg, node_addr=%s, msg=%s failed\n", node_addr, node_msgid2str( msg->msgid ) ); retval = -1; } node_dealloc_msg( msg ); return retval; }
void CacheQuorum::handle_push_local_ack() { #ifdef DEBUG printf("CACHE_NODE handle_push_local_ack\n"); print_msg_info(&(node->msg_info)); #endif int result; result = recv_msg(buf, msg_info->count, MPI_UINT8_T, msg_info->src, PUSH_LOCAL_ACK, msg_info->comm, status); MPI_ASSERT(result == MPI_SUCCESS); PutAckTemplate *put_ack = (PutAckTemplate *)buf; put_ack->result = SUCCESS; uint32_t job_num = put_ack->job_num; uint32_t job_node = put_ack->job_node; MPI_Comm job_comm = node->job_to_comms[job_num].job; // Reply back to original job node with outcome. result = send_msg(buf, sizeof(PushAckTemplate), MPI_UINT8_T, job_node, PUSH_LOCAL_ACK, job_comm, &request); MPI_ASSERT(result == MPI_SUCCESS); }
void proc_comm_connector(struct task_struct *task) { struct cn_msg *msg; struct proc_event *ev; __u8 buffer[CN_PROC_MSG_SIZE] __aligned(8); if (atomic_read(&proc_event_num_listeners) < 1) return; msg = buffer_to_cn_msg(buffer); ev = (struct proc_event *)msg->data; memset(&ev->event_data, 0, sizeof(ev->event_data)); ev->timestamp_ns = ktime_get_ns(); ev->what = PROC_EVENT_COMM; ev->event_data.comm.process_pid = task->pid; ev->event_data.comm.process_tgid = task->tgid; get_task_comm(ev->event_data.comm.comm, task); memcpy(&msg->id, &cn_proc_event_id, sizeof(msg->id)); msg->ack = 0; /* not used */ msg->len = sizeof(*ev); msg->flags = 0; /* not used */ send_msg(msg); }
int run_big_request_test (Test::Hello_ptr hello) { const int length = 40000; Test::Octet_Seq send_msg(length); send_msg.length (length); for (int i= 0; i<length; ++i) { send_msg[i]= static_cast<CORBA::Octet> (i & 0xff); } ACE_DEBUG((LM_DEBUG, ACE_TEXT("run_big_request_test, send = %d bytes\n"), length)); if (test == 2) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("*** NOTE TestCompressor is EXPECTED to throw IDL:omg.org/Compression/CompressionException ***\n"))); } hello->big_request(send_msg); return 0; }
/* * A MSG_STOP_LOCKSPACE message has been received. */ static void proto_stop_lockspace(struct node *node, const char *name) { struct lockspace *ls; ls = find_lockspace(name); if (!ls) ls = new_lockspace(name); /* * The lockspace will not be restarted until all bits in ls->stopping * (one for each peer node) have been cleared again. */ ls->stopping |= node_mask(node); /* * The ls->stopped bit for the local node indicates whether the * lockspace is active or stopped locally; new lockspaces start out * stopped. The ls->stopping bit for the local node indicates whether * we have already requested the kernel to stop the lockspace locally. */ if (ls->stopped & node_mask(local_node)) send_msg(node, MSG_LOCKSPACE_STOPPED, ls->name); else if (!(ls->stopping & node_mask(local_node))) stop_lockspace(ls); }
static int pkcs11_rsa_private_encrypt(int flen, const u_char *from, u_char *to, RSA *rsa, int padding) { Key key; u_char *blob, *signature = NULL; u_int blen, slen = 0; int ret = -1; Buffer msg; if (padding != RSA_PKCS1_PADDING) return (-1); key.type = KEY_RSA; key.rsa = rsa; if (key_to_blob(&key, &blob, &blen) == 0) return -1; buffer_init(&msg); buffer_put_char(&msg, SSH2_AGENTC_SIGN_REQUEST); buffer_put_string(&msg, blob, blen); buffer_put_string(&msg, from, flen); buffer_put_int(&msg, 0); free(blob); send_msg(&msg); buffer_clear(&msg); if (recv_msg(&msg) == SSH2_AGENT_SIGN_RESPONSE) { signature = buffer_get_string(&msg, &slen); if (slen <= (u_int)RSA_size(rsa)) { memcpy(to, signature, slen); ret = slen; } free(signature); } buffer_free(&msg); return (ret); }
int pkcs11_add_provider(char *name, char *pin, Key ***keysp) { Key *k; int i, nkeys; u_char *blob; u_int blen; Buffer msg; if (fd < 0 && pkcs11_start_helper() < 0) return (-1); buffer_init(&msg); buffer_put_char(&msg, SSH_AGENTC_ADD_SMARTCARD_KEY); buffer_put_cstring(&msg, name); buffer_put_cstring(&msg, pin); send_msg(&msg); buffer_clear(&msg); if (recv_msg(&msg) == SSH2_AGENT_IDENTITIES_ANSWER) { nkeys = buffer_get_int(&msg); *keysp = xcalloc(nkeys, sizeof(Key *)); for (i = 0; i < nkeys; i++) { blob = buffer_get_string(&msg, &blen); free(buffer_get_string(&msg, NULL)); k = key_from_blob(blob, blen); wrap_key(k->rsa); (*keysp)[i] = k; free(blob); } } else { nkeys = -1; } buffer_free(&msg); return (nkeys); }
static int _server_handle_vCont(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) { char *action = NULL; if (send_ack (g) < 0) { return -1; } g->data[g->data_len] = '\0'; if (g->data[5] == '?') { // Query about everything we support return send_msg (g, "vCont;c;s"); } if (!(action = strtok (g->data, ";"))) { return send_msg (g, "E01"); } while ((action = strtok (NULL, ";"))) { eprintf ("action: %s\n", action); switch (action[0]) { case 's': // TODO handle thread selections if (cmd_cb (g, core_ptr, "ds", NULL, 0) < 0) { send_msg (g, "E01"); return -1; } return send_msg (g, "OK"); case 'c': // TODO handle thread selections if (cmd_cb (g, core_ptr, "dc", NULL, 0) < 0) { send_msg (g, "E01"); return -1; } return send_msg (g, "OK"); default: // TODO support others return send_msg (g, "E01"); } } return -1; }
int main(int argc, char **argv) { struct mrpc_conn_set *sset; struct mrpc_conn_set *cset; struct mrpc_connection *conn; struct sockaddr_in addr; socklen_t addrlen; char *set_port; char skt_port[8]; int cfd; int lfd; int sfd; unsigned seq; mrpc_status_t expected; int expected_ioerrs=0; if (sem_init(&cb_complete, 0, 0)) die("Couldn't initialize semaphore"); sset=spawn_server(&set_port, proto_server, sync_server_accept, NULL, 1); mrpc_set_disconnect_func(sset, disconnect_normal); mrpc_set_ioerr_func(sset, handle_ioerr); if (mrpc_conn_set_create(&cset, proto_client, NULL)) die("Couldn't create client conn set"); mrpc_set_disconnect_func(cset, disconnect_normal); mrpc_set_ioerr_func(cset, handle_ioerr); start_monitored_dispatcher(cset); cfd=socket(PF_INET, SOCK_STREAM, 0); if (cfd == -1) die("Couldn't create socket"); addr.sin_family=AF_INET; addr.sin_port=htons(atoi(set_port)); addr.sin_addr.s_addr=htonl(INADDR_LOOPBACK); if (connect(cfd, (struct sockaddr *)&addr, sizeof(addr))) die("Couldn't connect socket"); free(set_port); lfd=socket(PF_INET, SOCK_STREAM, 0); if (lfd == -1) die("Couldn't create socket"); addr.sin_port=0; if (bind(lfd, (struct sockaddr *)&addr, sizeof(addr))) die("Couldn't bind socket"); if (listen(lfd, 16)) die("Couldn't listen on socket"); addrlen=sizeof(addr); if (getsockname(lfd, (struct sockaddr *)&addr, &addrlen)) die("Couldn't get socket name"); snprintf(skt_port, sizeof(skt_port), "%u", ntohs(addr.sin_port)); if (mrpc_conn_create(&conn, cset, NULL)) die("Couldn't create conn handle"); if (mrpc_connect(conn, AF_INET, NULL, skt_port)) die("Couldn't connect to listening socket"); sfd=accept(lfd, NULL, NULL); if (sfd == -1) die("Couldn't accept incoming connection"); close(lfd); /* Successful ping on raw client */ send_msg(cfd, 0, MINIRPC_PENDING, nr_proto_ping, 0); recv_msg(cfd, &seq, MINIRPC_OK, nr_proto_ping, 0); expect(seq, 0); /* Successful ping on raw server */ expected=0; expect(proto_ping_async(conn, cb_ping, &expected), 0); recv_msg(sfd, &seq, MINIRPC_PENDING, nr_proto_ping, 0); send_msg(sfd, seq, MINIRPC_OK, nr_proto_ping, 0); sem_wait(&cb_complete); /* Request payload too short */ send_msg(cfd, 1, MINIRPC_PENDING, nr_proto_send_buffer, 500); recv_msg(cfd, &seq, MINIRPC_ENCODING_ERR, nr_proto_send_buffer, 0); expect(seq, 1); expected_ioerrs++; /* Request payload too long */ send_msg(cfd, 2, MINIRPC_PENDING, nr_proto_send_buffer, 2000); recv_msg(cfd, &seq, MINIRPC_ENCODING_ERR, nr_proto_send_buffer, 0); expect(seq, 2); expected_ioerrs++; /* Zero-length request payload when expecting non-zero */ send_msg(cfd, 3, MINIRPC_PENDING, nr_proto_send_buffer, 0); recv_msg(cfd, &seq, MINIRPC_ENCODING_ERR, nr_proto_send_buffer, 0); expect(seq, 3); expected_ioerrs++; /* Bogus procedure */ send_msg(cfd, 4, MINIRPC_PENDING, 12345, 500); recv_msg(cfd, &seq, MINIRPC_PROCEDURE_UNAVAIL, 12345, 0); expect(seq, 4); /* Procedure call against NULL operations pointer */ send_msg(sfd, 5, MINIRPC_PENDING, nr_proto_client_check_int, 4); recv_msg(sfd, &seq, MINIRPC_PROCEDURE_UNAVAIL, nr_proto_client_check_int, 0); expect(seq, 5); /* Call against procedure zero */ send_msg(cfd, 6, MINIRPC_PENDING, 0, 0); recv_msg(cfd, &seq, MINIRPC_PROCEDURE_UNAVAIL, 0, 0); expect(seq, 6); /* Reply payload too short */ expected=MINIRPC_ENCODING_ERR; expect(proto_recv_buffer_async(conn, cb_recv, &expected), 0); recv_msg(sfd, &seq, MINIRPC_PENDING, nr_proto_recv_buffer, 0); send_msg(sfd, seq, MINIRPC_OK, nr_proto_recv_buffer, 500); sem_wait(&cb_complete); expected_ioerrs++; /* Reply payload too long */ expected=MINIRPC_ENCODING_ERR; expect(proto_recv_buffer_async(conn, cb_recv, &expected), 0); recv_msg(sfd, &seq, MINIRPC_PENDING, nr_proto_recv_buffer, 0); send_msg(sfd, seq, MINIRPC_OK, nr_proto_recv_buffer, 2000); sem_wait(&cb_complete); expected_ioerrs++; /* Zero-length reply payload when expecting nonzero */ expected=MINIRPC_ENCODING_ERR; expect(proto_recv_buffer_async(conn, cb_recv, &expected), 0); recv_msg(sfd, &seq, MINIRPC_PENDING, nr_proto_recv_buffer, 0); send_msg(sfd, seq, MINIRPC_OK, nr_proto_recv_buffer, 0); sem_wait(&cb_complete); expected_ioerrs++; /* Successful recv_buffer call (sanity check) */ expected=MINIRPC_OK; expect(proto_recv_buffer_async(conn, cb_recv, &expected), 0); recv_msg(sfd, &seq, MINIRPC_PENDING, nr_proto_recv_buffer, 0); send_msg(sfd, seq, MINIRPC_OK, nr_proto_recv_buffer, 1024); sem_wait(&cb_complete); /* Reply with both error code and payload */ expected=MINIRPC_ENCODING_ERR; expect(proto_recv_buffer_async(conn, cb_recv, &expected), 0); recv_msg(sfd, &seq, MINIRPC_PENDING, nr_proto_recv_buffer, 0); send_msg(sfd, seq, 25, nr_proto_recv_buffer, 1024); sem_wait(&cb_complete); expected_ioerrs++; /* Reply with command not matching request command */ expected=MINIRPC_ENCODING_ERR; expect(proto_ping_async(conn, cb_ping, &expected), 0); recv_msg(sfd, &seq, MINIRPC_PENDING, nr_proto_ping, 0); send_msg(sfd, seq, MINIRPC_OK, nr_proto_send_buffer, 0); sem_wait(&cb_complete); expected_ioerrs++; /* Unmatched reply */ send_msg(cfd, 7, MINIRPC_OK, nr_proto_ping, 0); expected_ioerrs++; /* Unidirectional message with error code */ send_msg(cfd, 8, MINIRPC_OK, nr_proto_msg_buffer, 1024); expected_ioerrs++; /* Empty event queues before closing, to make sure that no ioerr events are squashed */ send_msg(cfd, 0, MINIRPC_PENDING, nr_proto_ping, 0); recv_msg(cfd, &seq, MINIRPC_OK, nr_proto_ping, 0); expect(seq, 0); expected=0; expect(proto_ping_async(conn, cb_ping, &expected), 0); recv_msg(sfd, &seq, MINIRPC_PENDING, nr_proto_ping, 0); send_msg(sfd, seq, MINIRPC_OK, nr_proto_ping, 0); sem_wait(&cb_complete); close(cfd); close(sfd); mrpc_listen_close(sset); mrpc_conn_set_unref(sset); mrpc_conn_set_unref(cset); expect_disconnects(0, 2, 0); expect_ioerrs(expected_ioerrs); sem_destroy(&cb_complete); return 0; }
/* this is the underlying (unformatted) rsync debugging function. Call * it with FINFO, FERROR_*, FWARNING, FLOG, or FCLIENT. Note: recursion * can happen with certain fatal conditions. */ void rwrite(enum logcode code, const char *buf, int len, int is_utf8) { int trailing_CR_or_NL; FILE *f = msgs2stderr ? stderr : stdout; #ifdef ICONV_OPTION iconv_t ic = is_utf8 && ic_recv != (iconv_t)-1 ? ic_recv : ic_chck; #else #ifdef ICONV_CONST iconv_t ic = ic_chck; #endif #endif if (len < 0) exit_cleanup(RERR_MESSAGEIO); if (msgs2stderr) { if (!am_daemon) { if (code == FLOG) return; goto output_msg; } if (code == FCLIENT) return; code = FLOG; } else if (send_msgs_to_gen) { assert(!is_utf8); /* Pass the message to our sibling in native charset. */ send_msg((enum msgcode)code, buf, len, 0); return; } if (code == FERROR_SOCKET) /* This gets simplified for a non-sibling. */ code = FERROR; else if (code == FERROR_UTF8) { is_utf8 = 1; code = FERROR; } if (code == FCLIENT) code = FINFO; else if (am_daemon || logfile_name) { static int in_block; char msg[2048]; int priority = code == FINFO || code == FLOG ? LOG_INFO : LOG_WARNING; if (in_block) return; in_block = 1; if (!log_initialised) log_init(0); strlcpy(msg, buf, MIN((int)sizeof msg, len + 1)); logit(priority, msg); in_block = 0; if (code == FLOG || (am_daemon && !am_server)) return; } else if (code == FLOG) return; if (quiet && code == FINFO) return; if (am_server) { enum msgcode msg = (enum msgcode)code; if (protocol_version < 30) { if (msg == MSG_ERROR) msg = MSG_ERROR_XFER; else if (msg == MSG_WARNING) msg = MSG_INFO; } /* Pass the message to the non-server side. */ if (send_msg(msg, buf, len, !is_utf8)) return; if (am_daemon) { /* TODO: can we send the error to the user somehow? */ return; } f = stderr; } output_msg: switch (code) { case FERROR_XFER: got_xfer_error = 1; /* FALL THROUGH */ case FERROR: case FERROR_UTF8: case FERROR_SOCKET: case FWARNING: f = stderr; break; case FLOG: case FINFO: case FCLIENT: break; default: fprintf(stderr, "Unknown logcode in rwrite(): %d [%s]\n", (int)code, who_am_i()); exit_cleanup(RERR_MESSAGEIO); } if (output_needs_newline) { fputc('\n', f); output_needs_newline = 0; } trailing_CR_or_NL = len && (buf[len-1] == '\n' || buf[len-1] == '\r') ? buf[--len] : 0; if (len && buf[0] == '\r') { fputc('\r', f); buf++; len--; } #ifdef ICONV_CONST if (ic != (iconv_t)-1) { xbuf outbuf, inbuf; char convbuf[1024]; int ierrno; INIT_CONST_XBUF(outbuf, convbuf); INIT_XBUF(inbuf, (char*)buf, len, (size_t)-1); while (inbuf.len) { iconvbufs(ic, &inbuf, &outbuf, inbuf.pos ? 0 : ICB_INIT); ierrno = errno; if (outbuf.len) { filtered_fwrite(f, convbuf, outbuf.len, 0); outbuf.len = 0; } if (!ierrno || ierrno == E2BIG) continue; fprintf(f, "\\#%03o", CVAL(inbuf.buf, inbuf.pos++)); inbuf.len--; } } else #endif filtered_fwrite(f, buf, len, !allow_8bit_chars); if (trailing_CR_or_NL) { fputc(trailing_CR_or_NL, f); fflush(f); } }
/* Main loop to listen for packets on a wireless card in monitor mode. */ enum wps_result do_wps_exchange() { struct pcap_pkthdr header; const u_char *packet = NULL; enum wps_type packet_type = UNKNOWN, last_msg = UNKNOWN; enum wps_result ret_val = KEY_ACCEPTED; int premature_timeout = 0, terminated = 0, got_nack = 0; int id_response_sent = 0, tx_type = 0; int m2_sent = 0, m4_sent = 0, m6_sent = 0; /* Initialize settings for this WPS exchange */ set_last_wps_state(0); set_eap_id(0); /* Initiate an EAP session */ send_eapol_start(); /* * Loop until: * * o The pin has been cracked * o An EAP_FAIL packet is received * o We receive a NACK message * o We hit an unrecoverable receive timeout */ while ((get_key_status() != KEY_DONE) && !terminated && !got_nack && !premature_timeout) { tx_type = 0; if (packet_type > last_msg) { last_msg = packet_type; } packet = next_packet(&header); if (packet == NULL) { break; } packet_type = process_packet(packet, &header); memset((void *) packet, 0, header.len); switch (packet_type) { case IDENTITY_REQUEST: cprintf(VERBOSE, "[+] Received identity request\n"); tx_type = IDENTITY_RESPONSE; id_response_sent = 1; break; case M1: cprintf(VERBOSE, "[+] Received \033[1;35mM1\033[0m message\n"); if (id_response_sent && !m2_sent) { tx_type = SEND_M2; m2_sent = 1; } else if (get_oo_send_nack()) { tx_type = SEND_WSC_NACK; terminated = 1; } break; case M3: cprintf(VERBOSE, "[+] Received \033[1;35mM3\033[0m message\n"); if (m2_sent && !m4_sent) { if (globule->pixie_loop == 1) { tx_type = SEND_WSC_NACK; terminated = 1; } else if (globule->pixie_loop == 0) { tx_type = SEND_M4; m4_sent = 1; } //tx_type = SEND_M4; //m4_sent = 1; } else if (get_oo_send_nack()) { tx_type = SEND_WSC_NACK; terminated = 1; } break; case M5: cprintf(VERBOSE, "[+] Received \033[1;35mM5\033[0m message\n"); if (get_key_status() == KEY1_WIP) { set_key_status(KEY2_WIP); } if (m4_sent && !m6_sent) { tx_type = SEND_M6; m6_sent = 1; } else if (get_oo_send_nack()) { tx_type = SEND_WSC_NACK; terminated = 1; } break; case M7: cprintf(VERBOSE, "[+] Received \033[1;35mM7\033[0m message\n"); //bug fix made by flatr0ze if (!m6_sent) { tx_type = SEND_WSC_NACK; terminated = 1; } /* Fall through */ case DONE: if (get_key_status() == KEY2_WIP) { set_key_status(KEY_DONE); } tx_type = SEND_WSC_NACK; break; case NACK: cprintf(VERBOSE, "[+] Received WSC NACK (reason: 0x%04X)\n", get_nack_reason()); got_nack = 1; break; case TERMINATE: terminated = 1; break; default: if (packet_type != 0) { cprintf(VERBOSE, "[!] WARNING: Unexpected packet received (0x%.02X), terminating transaction\n", packet_type); terminated = 1; } break; } if (tx_type == IDENTITY_RESPONSE) { send_identity_response(); } else if (tx_type) { send_msg(tx_type); } /* * If get_oo_send_nack is 0, then when out of order packets come, we don't * NACK them. However, this also means that we wait infinitely for the expected * packet, since the timer is started by send_msg. Manually start the timer to * prevent infinite loops. */ else if (packet_type != 0) { start_timer(); } /* Check to see if our receive timeout has expired */ if (get_out_of_time()) { /* If we have not sent an identity response, try to initiate an EAP session again */ if (!id_response_sent) { /* Notify the user after EAPOL_START_MAX_TRIES eap start failures */ if (get_eapol_start_count() == EAPOL_START_MAX_TRIES) { cprintf(WARNING, "[!] WARNING: %d successive start failures\n", EAPOL_START_MAX_TRIES); set_eapol_start_count(0); premature_timeout = 1; } send_eapol_start(); } else { /* Treat all other time outs as unexpected errors */ premature_timeout = 1; } } } /* * There are four states that can signify a pin failure: * * o Got NACK instead of an M5 message (first half of pin wrong) * o Got NACK instead of an M5 message, when cracking second half (fake NACK) * o Got NACK instead of an M7 message (second half of pin wrong) * o Got receive timeout while waiting for an M5 message (first half of pin wrong) * o Got receive timeout while waiting for an M7 message (second half of pin wrong) */ if (got_nack) { /* * If a NACK message was received, then the current wps->state value will be * SEND_WSC_NACK, indicating that we need to reply with a NACK. So check the * previous state to see what state we were in when the NACK was received. */ /* Warning the user about change of reason code for the received NACK message. */ if (!get_ignore_nack_reason()) { if ((get_last_nack_reason() >= 0) && (get_nack_reason() != get_last_nack_reason())) { cprintf(WARNING, "[!] WARNING: The reason code for NACK has been changed. Potential FAKE NACK!\n"); } set_last_nack_reason(get_nack_reason()); } /* Check NACK reason code for */ if ((get_fake_nack_reason() >= 0) && (get_nack_reason() == get_fake_nack_reason()) && (get_timeout_is_nack())) { ret_val = FAKE_NACK; } else { if ((last_msg == M3) || (last_msg == M5)) { /* The AP is properly sending WSC_NACKs, so don't treat future timeouts as pin failures. */ set_timeout_is_nack(0); /* bug fix made by KokoSoft */ ret_val = ((last_msg == M3) && (get_key_status() == KEY2_WIP) && (get_timeout_is_nack())) ? FAKE_NACK : KEY_REJECTED; } else { ret_val = UNKNOWN_ERROR; } } } else if (premature_timeout) { /* * Some WPS implementations simply drop the connection on the floor instead of sending a NACK. * We need to be able to handle this, but at the same time using a timeout on the M5/M7 messages * can result in false negatives. Thus, treating M5/M7 receive timeouts as NACKs can be disabled. * Only treat the timeout as a NACK if this feature is enabled. */ if (get_timeout_is_nack() && //(last_msg == M3 || last_msg == M5)) ((last_msg == M3 && (get_key_status() == KEY1_WIP)) || last_msg == M5)) //bug fix made by flatr0ze { ret_val = KEY_REJECTED; } else { /* If we timed out at any other point in the session, then we need to try the pin again */ ret_val = RX_TIMEOUT; } } /* * If we got an EAP FAIL message without a preceeding NACK, then something went wrong. * This should be treated the same as a RX_TIMEOUT by the caller: try the pin again. */ else if (terminated) { ret_val = EAP_FAIL; } else if (get_key_status() != KEY_DONE) { ret_val = UNKNOWN_ERROR; } /* * Always completely terminate the WPS session, else some WPS state machines may * get stuck in their current state and won't accept new WPS registrar requests * until rebooted. * * Stop the receive timer that is started by the termination transmission. */ send_wsc_nack(); stop_timer(); if (get_eap_terminate() || ret_val == EAP_FAIL) { send_termination(); stop_timer(); } return ret_val; }