示例#1
0
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);
}
示例#2
0
文件: nltest.c 项目: openSUSE/lldpad
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;
}
示例#3
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;
}
示例#4
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);
}
示例#5
0
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);
}
示例#6
0
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);
}
示例#7
0
/*
 * 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);

}
示例#8
0
/* 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;
}
示例#9
0
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;
}
示例#11
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();
}
示例#12
0
文件: iq.c 项目: dnozay/CEnsemble
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 ;
}
示例#13
0
/* 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);
	}
示例#14
0
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);

}
示例#15
0
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;
}
示例#16
0
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");
        }
    }
}
示例#17
0
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  */

}
示例#18
0
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);
}
示例#19
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;
}
示例#20
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;
}
示例#21
0
文件: 2724.c 项目: ZhouWeikuan/zoj
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;
}
示例#22
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;
			}
		}
	}
示例#23
0
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);
}
示例#25
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);
}
示例#26
0
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;
}
示例#27
0
文件: get.c 项目: semyda94/safeTFTP
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;
}
示例#28
0
文件: 102chiffrement.c 项目: k6s/tek1
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);
}
示例#29
0
/*
 * 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;
	}
}
示例#30
0
/*
 * 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