foreign_t send_now(term_t addr, term_t msg, term_t args) { lo_address a; char *m; return get_addr(addr,&a) && get_msg(msg, &m) && send_msg(a,m,args); }
static int get_pfc_cfg(char *ifname, __u8 *pfc) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *rta_parent, *rta_child; int i; nlh = start_msg(RTM_GETDCB, DCB_CMD_PFC_GCFG); if (NULL==nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); rta_parent = add_rta(nlh, DCB_ATTR_PFC_CFG, NULL, 0); rta_child = add_rta(nlh, DCB_PFC_UP_ATTR_ALL, NULL, 0); rta_parent->rta_len += NLMSG_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; nlh = get_msg(); if (!nlh) return -EIO; d = (struct dcbmsg *)NLMSG_DATA(nlh); rta_parent = (struct rtattr *)(((char *)d) + NLMSG_ALIGN(sizeof(struct dcbmsg))); if (d->cmd != DCB_CMD_PFC_GCFG) { printf("Hmm, this is not the message we were expecting.\n"); return -EIO; } if (rta_parent->rta_type != DCB_ATTR_PFC_CFG) { /* Do we really want to code up an attribute parser?? */ printf("A full libnetlink (with genl and attribute support) " "would sure be nice.\n"); return -EIO; } rta_child = NLA_DATA(rta_parent); rta_parent = (struct rtattr *)((char *)rta_parent + NLMSG_ALIGN(rta_parent->rta_len)); for (i = 0; rta_parent > rta_child; i++) { if (i == 8) { printf("pfc array out of range\n"); break; } pfc[rta_child->rta_type - DCB_PFC_UP_ATTR_0] = *(__u8 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); } if (rta_parent != rta_child) printf("rta pointers are off\n"); return 0; }
int main(int argc, char ** argv) { assert(argc == 3); uint64_t msg_size = atoi(argv[1]); int loop_length = atoi(argv[2]); bsparrow_t * bsp = bsparrow_new(50000, 4000, 2, 2, 1, "9003"); bsparrow_event_t bspev; bsparrow_socket_t * bsock; bsparrow_wait(bsp, &bspev, 0); if(bspev.event & 16) { bsock = bspev.bsock; bsparrow_socket_assign_id(bsock, 1); } else { exit(-1); } sparrow_msg_t msg; int j = 0; int64_t time = now(); while(j < loop_length) { int i = 0; while(i < 10000) { if(i == 5000) { char *data = scalloc(1, 100); uint64_t temp = 92; memcpy(data, &temp, 8); sprintf(data + 8,"Got 50, need mooooreee!"); bsparrow_send(bsp, bsock, &data, 100); Dprintf("I am sending an aknowledge msg at msg number: %lu\n", j*100 + 50); } get_msg(bsp, bsock, &bspev, &msg); Dprintf("i: %d\n", i); Dprintf("Remaining length: %lu\n", bspev.total_length -msg_size); printmsg(msg); i++; } Dprintf("j: %d\n", j); Dprintf("Remaining length: %lu\n", bspev.total_length -msg_size); j++; } printf("Sending: Got them all, thanks!\n"); char *data = scalloc(1, 100); uint64_t temp = 92; memcpy(data, &temp, 8); sprintf(data + 8, "Got them all, thanks!"); bsparrow_send(bsp, bsock, &data, 100); results(j*10000, time, msg_size); bsparrow_destroy(bsp); return 0; }
/* * 重新装填信息包到本进程的收件箱中 */ int reload_msg(MSG *msg){ MSG *p_msg; p_msg = get_msg(); p_msg -> type = MSG_RELOAD; p_msg -> int_info[0] = (int)msg; return send_msg(p_msg); }
foreign_t send_at(term_t addr, term_t msg, term_t args, term_t time) { lo_address a; lo_timetag ts; char *m; return get_addr(addr,&a) && get_prolog_time(time,&ts) && get_msg(msg, &m) && send_msg_timestamped(a,&ts,m,args); }
foreign_t send_timestamped(term_t addr, term_t msg, term_t args, term_t secs, term_t frac) { lo_address a; lo_timetag ts; char *m; return get_addr(addr,&a) && get_timetag(secs,frac,&ts) && get_msg(msg, &m) && send_msg_timestamped(a,&ts,m,args); }
/* * int hd_open(); * 打开硬盘驱动。获取硬盘信息 * 成功返回0否则返回-1 */ int hd_open(){ MSG *p_msg; p_msg = get_msg(); p_msg -> type = MSG_HD_OPEN; p_msg -> recv_pid = TASK_HD; return send_msg(p_msg); }
/* The sample content handler */ static int sstats_handler(request_rec *r) { if (strcmp(r->handler, "sstats")) { return DECLINED; } r->content_type = "text/html"; // if (!r->header_only) ap_rputs(get_msg(), r); return OK; }
struct sftp_conn * do_init(int fd_in, int fd_out, u_int transfer_buflen, u_int num_requests) { u_int type; int version; Buffer msg; struct sftp_conn *ret; buffer_init(&msg); buffer_put_char(&msg, SSH2_FXP_INIT); buffer_put_int(&msg, SSH2_FILEXFER_VERSION); send_msg(fd_out, &msg); buffer_clear(&msg); get_msg(fd_in, &msg); /* Expecting a VERSION reply */ if ((type = buffer_get_char(&msg)) != SSH2_FXP_VERSION) { error("Invalid packet back from SSH2_FXP_INIT (type %u)", type); buffer_free(&msg); return(NULL); } version = buffer_get_int(&msg); debug2("Remote version: %d", version); /* Check for extensions */ while (buffer_len(&msg) > 0) { char *name = buffer_get_string(&msg, NULL); char *value = buffer_get_string(&msg, NULL); debug2("Init extension: \"%s\"", name); xfree(name); xfree(value); } buffer_free(&msg); ret = xmalloc(sizeof(*ret)); ret->fd_in = fd_in; ret->fd_out = fd_out; ret->transfer_buflen = transfer_buflen; ret->num_requests = num_requests; ret->version = version; ret->msg_id = 1; /* Some filexfer v.0 servers don't support large packets */ if (version == 0) ret->transfer_buflen = MIN(ret->transfer_buflen, 20480); return(ret); }
/** * receive message from given sender */ asmlinkage long sys_RcvMsg(pid_t *sender, void *msg, int *len, bool block){ pid_t my_pid = current->pid; mailbox* mb = NULL; signal* signal = NULL; message* this_mail; pid_t *a_sender; void *a_msg; int *a_len; signal = get_signal(my_pid); if (signal == NULL) { signal = create_signal(my_pid, TRUE); wait_event(signal->wait_null, mb != NULL); } mb = get_mailbox(my_pid); if ((mb->stop) && (mb->size == 0)) return MAILBOX_STOPPED; if ((block == NO_BLOCK) && (mb->size == 0)) return MAILBOX_EMPTY; if ((block == BLOCK) && (mb->size == 0)) { wait_event(mb->wait_empty, mb->size != 0); printk("LLLLLLLLLLLOOOPPPP"); } spin_lock(&(mb->lock)); this_mail = get_msg(&mb); spin_unlock(&(mb->lock)); if (this_mail == NULL) return MAILBOX_ERROR;; a_sender = &(this_mail->sender); a_msg = this_mail->content; a_len = &(this_mail->len); if (((*a_len) > MAX_MSG_SIZE) || ((*a_len) < 0)) return MSG_LENGTH_ERROR; if ((copy_to_user(sender, a_sender, sizeof(pid_t)))) return MSG_ARG_ERROR; if ((copy_to_user(msg, a_msg, *a_len))) return MSG_ARG_ERROR; if ((copy_to_user(len, a_len, sizeof(int)))) return MSG_ARG_ERROR; spin_lock(&(mb->lock)); rm_message(&mb); spin_unlock(&(mb->lock)); //successful return 0; }
/* * int close(int fd); * * 关闭文件。 * 如果关闭文件之后还有进程处于打开队列之中将会唤醒下一个进程 * 如果没有进程了将撤销该fd * *@param:通过open返回的文件描述符 * * 返回值: * 成功返回0失败返回-1 */ int close(int fd){ MSG *p_msg; p_msg = get_msg(); p_msg->type = MSG_CLOSE; p_msg->recv_pid = TASK_FS; p_msg->int_info[0] = fd; assert(send_msg(p_msg) == 0); return pause(); }
bool_t iq_read_prefix(iq_t iq, seqno_t *seqno, iq_item_t *msg) { seqno_t read = iq->read ; item_t *item ; if (!get_msg(iq, read)) { return FALSE ; } item = get_unsafe(iq, read) ; *msg = item->msg ; *seqno = read ; iq->read = read + 1 ; return TRUE ; }
/* open file descriptor and attach */ static int dl_open(const char *dev, int unit, int *fd){ dl_attach_req_t *attach_req = (dl_attach_req_t *)ctl_area; if((*fd = open(dev, O_RDWR)) == -1){ printf(_("Error: DLPI stream API failed to get MAC in dl_attach_req/open(%s..): %s.\n"), dev, strerror(errno)); exit(STATE_UNKNOWN); } attach_req->dl_primitive = DL_ATTACH_REQ; attach_req->dl_ppa = unit; put_ctrl(*fd, sizeof(dl_attach_req_t), 0); get_msg(*fd); return check_ctrl(DL_OK_ACK); }
void hd_handler(){ MSG *p_msg; u8 status; status = in_byte((u32) REG_STATUS); //表示可以再次接收中断 p_msg = get_msg(); //向硬盘驱动程序发送信号。表示READY p_msg -> type = MSG_SIGNAL; p_msg -> recv_pid = TASK_HD; p_msg -> signal = SIG_READY; post_msg(p_msg); }
foreign_t del_handler(term_t server, term_t msg, term_t types) { my_server_thread s; char *pattern, *typespec; char buffer[256]; // !! space for up to 255 arguments int rc; rc = get_server(server,&s) && get_msg(msg,&pattern) && get_types(types,buffer,256,&typespec); if (rc) lo_server_del_method(s->s,pattern,typespec); return rc; }
void check_clients() { int i, connfd; char buf[MAXLINE]; rio_t rio; for (i = 0; (i <= p.maxi) && (p.nready > 0); i++) { connfd = p.clientfd[i]; rio = p.clientrio[i]; if ((connfd > 0) && FD_ISSET(connfd, &p.ready_set)){ p.nready--; if (Rio_readlineb(&rio, buf, MAXLINE) > 0) { get_msg(buf,buf); request_check(i, buf); while( rio.rio_cnt > 0 ){ Rio_readlineb(&rio,buf,MAXLINE); get_msg(buf,buf); request_check(i,buf); } } else{/* EOF detected. User Exit */ //debug char buf[MAX_MSG_LEN]; show_user(buf,MAX_MSG_LEN,user_table[connfd]); printf("!!Exit%s\n", buf); /* do quit command for user at connfd[i] */ quit_command(i); } //debug debug_list_all_user(); debug_list_all_channel(); printf("===================================\n"); } } }
void nps_fdm_run_step(bool launch __attribute__((unused)), double *commands, int commands_nb) { // read state if (get_msg(&crrcsim, crrcsim.data_buffer) <= 0) { return; // nothing on the socket } // send commands send_servo_cmd(&crrcsim, commands); //printf("new data %c %c\n", crrcsim.data_buffer[2], crrcsim.data_buffer[33]); switch (crrcsim.data_buffer[2]) { case 'S': /* IMU packet without GPS */ decode_imupacket(&fdm, crrcsim.data_buffer); break; case 'N': /* IMU packet with GPS */ decode_imupacket(&fdm, crrcsim.data_buffer); /****************************************** *check GPS data packet ******************************************/ //if(data_buffer[31]==(byte)0x55 && data_buffer[32]==(byte)0x55 && data_buffer[33]=='G') if (crrcsim.data_buffer[33] == 'G') { decode_gpspacket(&fdm, &crrcsim.data_buffer[31]); } break; case 'I': /* IMU packet with GPS and AHRS */ decode_imupacket(&fdm, crrcsim.data_buffer); /****************************************** *check GPS data packet ******************************************/ if (crrcsim.data_buffer[33] == 'G') { decode_gpspacket(&fdm, &crrcsim.data_buffer[31]); } if (crrcsim.data_buffer[66] == 'A') { decode_ahrspacket(&fdm, &crrcsim.data_buffer[66]); } break; default : printf("invalid data packet...!\n"); } /* end case */ }
static inline void* process_msg_thread(void *data){ msg_t msg; int id = (int) data; while(get_msg(msg,id)){ //the difference between single and multi if(callback_tab.find(msg["action"].asString()) == callback_tab.end()){ log(WARN,"[SYS WARN]\twrong action!"); continue; } callback_tab[msg["action"].asString()](id,msg["param"]); } close(id); pthread_exit(0); }
int MsgTask::svc (void) { Message * m =0 ; while (!stop_) { if ( get_msg(m) == 0) { assert(m); (void) handle_msg(*m); delete m; } } return 0; }
void fppmess( int errno, ...) { va_list plist; char *fname; char const *msg_kind; int lineno; if (!errno) return; va_start(plist,errno); switch (get_msg_severity(errno)) { case 1: if (warnfl) return; msg_kind = get_msg(MSG_WARNING); break; case 2: msg_kind = get_msg(MSG_ERROR); errnum++; break; case 3: msg_kind = get_msg(MSG_FATAL); break; default: error_vprint(NULL, 0, 0, NULL, get_msg(errno), plist); return; } fname = get_cur_fname(); lineno = get_err_lineno(); error_vprint(fname, lineno, 0, msg_kind, get_msg(errno), plist); if (get_msg_severity(errno) == 3) my_exit(1); return; }
int main(){ char buf[8]; last = num = top = 0; scanf("%s", buf); while(!feof(stdin)){ if(buf[0]=='G'){ get_msg(); } else { put_msg(); } scanf("%s", buf); } return 0; }
inline void InitDialogItemsF(const InitDialogItemF *Init, FarDialogItem *Item, int ItemsNumber) { for (int i = 0; i < ItemsNumber; ++i) { WinMem::Zero(Item[i]); Item[i].Type = Init[i].Type; Item[i].X1 = Init[i].X1; Item[i].Y1 = Init[i].Y1; Item[i].X2 = Init[i].X2; Item[i].Y2 = Init[i].Y2; Item[i].Flags = Init[i].Flags; if ((DWORD_PTR)Init[i].Data < 2048) { Item[i].PtrData = get_msg((size_t)Init[i].Data); } else { Item[i].PtrData = Init[i].Data; } } }
char * do_realpath(struct sftp_conn *conn, char *path) { Buffer msg; u_int type, expected_id, count, id; char *filename, *longname; /* LINTED */ Attrib *a; expected_id = id = conn->msg_id++; send_string_request(conn->fd_out, id, SSH2_FXP_REALPATH, path, strlen(path)); buffer_init(&msg); get_msg(conn->fd_in, &msg); type = buffer_get_char(&msg); id = buffer_get_int(&msg); if (id != expected_id) fatal("ID mismatch (%u != %u)", id, expected_id); if (type == SSH2_FXP_STATUS) { u_int status = buffer_get_int(&msg); error("Couldn't canonicalise: %s", fx2txt(status)); return(NULL); } else if (type != SSH2_FXP_NAME) fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", SSH2_FXP_NAME, type); count = buffer_get_int(&msg); if (count != 1) fatal("Got multiple names (%d) from SSH_FXP_REALPATH", count); filename = buffer_get_string(&msg, NULL); longname = buffer_get_string(&msg, NULL); a = decode_attrib(&msg); debug3("SSH_FXP_REALPATH %s -> %s", path, filename); xfree(longname); buffer_free(&msg); return(filename); }
int recv_client_req(t_client *clt, t_trame *req) { SDLNet_SocketSet sset; sset = SDLNet_AllocSocketSet(1); SDLNet_TCP_AddSocket(sset, clt->sock); while (32) { if (SDLNet_CheckSockets(sset, (Uint32)-1) < 0) return (put_error("recv_client_req failed")); if (SDLNet_SocketReady(clt->sock) && get_msg(clt, req)) return (0); else if (clt->loss > NET_MAXLOSS) return (1); } return (0); }
struct shaft_conn * do_init(int fd_in, int fd_out, struct shaft_flow *flow) { u_int type, version; Buffer msg; struct shaft_conn *ret; buffer_init(&msg); buffer_put_char(&msg, SHAFT_INIT); buffer_put_int(&msg, SHAFT_VERSION); buffer_put_cstring(&msg, flow->local); send_msg(fd_out, &msg); buffer_clear(&msg); get_msg(fd_in, &msg); /* Expecting a VERSION reply */ if ((type = buffer_get_char(&msg)) != SHAFT_VERSION) { error("Invalid packet back from SHAFT_INIT (type %u)", version); buffer_free(&msg); return(NULL); } version = buffer_get_int(&msg); flow->dst = buffer_get_cstring(&msg, NULL); if (flow->dst == NULL) { error("Invalid packet back from SHAFT_INIT remote addr is null"); buffer_free(&msg); return(NULL); } debug2("Remote version: %u", version); debug2("Remote Address: %s", flow->dst); buffer_free(&msg); ret = xmalloc(sizeof(*ret)); ret->fd_in = fd_in; ret->fd_out = fd_out; ret->version = version; ret->msg_id = 1; return(ret); }
foreign_t add_handler(term_t server, term_t msg, term_t types, term_t goal) { my_server_thread s; lo_method method; char *pattern, *typespec; char buffer[256]; // !! space for up to 255 arguments int rc; rc = get_server(server,&s) && get_msg(msg,&pattern) && get_types(types,buffer,256,&typespec); if (rc) { record_t goal_record=PL_record(goal); method = lo_server_add_method(s->s, pattern, typespec, prolog_handler, (void *)goal_record); } return rc; }
off_t recv_file(int s, off_t flen, off_t recv_len, list_data_server_t list_data_server, server_data_t *server_data, struct sockaddr_in main_server, struct sockaddr_in my_server) { socklen_t slen; fd_set rfds; struct timeval tv; off_t all_recv_len = 0; message_t msg; tv.tv_sec = 3; tv.tv_usec = 0; FD_ZERO(&rfds); FD_SET(s, &rfds); while (1) { select(s + 1, &rfds, NULL, NULL, &tv); if (FD_ISSET(s, &rfds)){ recvfrom(s, &recv_len, sizeof(recv_len), 0, (struct sockaddr*) &main_server, &slen); /*printf("recv from %hu", ntohs(main_server.sin_port));*/ all_recv_len = all_recv_len + recv_len; if (flen == all_recv_len) { break; } } else { int return_code; return_code = choise_main_server(s, list_data_server, server_data, &main_server, &my_server); if (1 == return_code) { return all_recv_len; break; } else { printf("Reconecter with %s:%hu\n", list_data_server.s_addr[server_data->count_servers], list_data_server.s_port[server_data->count_servers]); main_server.sin_port = htons(list_data_server.s_port[server_data->count_servers]); main_server.sin_addr.s_addr = inet_addr(list_data_server.s_addr[server_data->count_servers]); get_msg("Reconnect", &msg, server_data); sendto(s, &msg.buf, sizeof(msg.buf), 0, (struct sockaddr*)&main_server, sizeof(main_server)); recvfrom(s, &msg.buf, sizeof(msg.buf), 0, (struct sockaddr*)&main_server, &slen); printf("%s\n", msg.buf); } } } return all_recv_len; }
int *cypher(char *msg, int *key, int flag, char *base, size_t *msg_len) { int *res; int *msg_mtx; res = NULL; if (!flag) msg_mtx = get_msg(msg, msg_len); else msg_mtx = get_hidden(msg, msg_len, base); if (msg_mtx) { res = mult_mtx(msg_mtx, key, *msg_len); free(msg_mtx); } else perror("./102chiffrement"); return (res); }
/* * int do_write_hd(u8 *hd_buff , int driver , u32 abs_sec); * 用于向磁盘驱动程序hd.c发送消息。 * 功能是写hd_buff到磁盘driver的某绝对扇区abs_sec中。 * 一次写一个扇区。 * *@param0:磁盘缓冲区 *@param1:磁盘主设备号 *@param2:磁盘绝对扇区号 *成功返回0 失败返回-1 */ int do_write_hd(void *hd_buff , int driver , u32 abs_sec){ MSG *p_msg; p_msg = get_msg(); //封装消息 p_msg -> type = MSG_WRITE_HD; p_msg -> recv_pid = TASK_HD; p_msg -> int_info[0] = (int)hd_buff; p_msg -> int_info[1] = driver; p_msg -> int_info[2] = abs_sec; if(send_msg(p_msg) == 0){ //如果发送消息成功。要等待TASK_HD成功写入才能继续 wait(SIG_READY); return 0; }else{ return -1; } }
/* * ssize_t read(int fd , char *buff , size_t count); * * 从打开的文件里读取count个字节放入buff之中 * 文件的读标志将跟随读取移动,直到文件末尾或者读取结束 * 如果count为0则读取无用 * * @param0:打开的文件描述符 * @param1:字节缓冲区buff * @param2:欲读取的字节数 * * 返回值: * 成功返回实际读入的字节数,失败返回-1 */ ssize_t read(int fd , char *buff , size_t count){ if(count == 0){ return 0; } MSG *p_msg; p_msg = get_msg(); p_msg->type = MSG_READ; p_msg->recv_pid = TASK_FS; p_msg->int_info[0] = fd; p_msg->int_info[1] = (int)buff; p_msg->int_info[2] = (int)count; assert(send_msg(p_msg) == 0); return pause(); } //end f