Esempio n. 1
0
void msg_event_handler( int fd, int msgid, int event ) {
    char buf[PACK_DATA_SIZE];
    ssize_t n;
//	printf( "event 0x%03x for msg %d\n", event, msgid );
    switch ( event ) {
    case MSG_EVT_ACCEPT_READY:
        if ( msg_accept( fd, msgid ) != 0 )
            msg_set_read( fd, msgid );
        // These are commands
        break;
    case MSG_EVT_READ_READY:
        msg_clr_read( fd, msgid );

        n = msg_read( fd, msgid, buf, sizeof( buf ) );
        if ( n <= 0 ) {
            cleanup_connection( msg_get_type( fd, msgid ) );
            break;
        }

        if ( msg_get_type( fd, msgid ) < 0 ) {
            /* If the msgid is less than zero, it refers to a command and
               the message should not be routed to a file descriptor. */

            // the entire command must fit inside one transport
            command_handler( fd, msgid, buf, n );

        } else {
            zs_set_write( msg_get_type( fd, msgid ) );
            /* if msgid is zero or greater it refers to a socket file
               descriptor that the message should be routed to. */
            if ( zs_write( msg_get_type( fd, msgid ), buf, n ) == -1 )
                cleanup_connection( msg_get_type( fd, msgid ) );
        }
        break;
    case MSG_EVT_WRITE_READY:
        if ( msgid < 0 ) break;
        zs_set_read( msg_get_type( fd, msgid ) );
        msg_clr_write( fd, msgid );
        break;
    case MSG_SWITCH_EVT_IO_ERROR:
        //zclose( msg_switch->sockfd );
        if ( website_get_by_sockfd( fd ) )
            remove_website( fd );
        else {
            for ( n = 0; n < FD_SETSIZE; n++ ) {
                if ( msg_exists( fd, n ) ) {
                    if ( msg_get_type( fd, n ) > 0 )
                        cleanup_connection( msg_get_type( fd, n ) );
                    //	else
                    //		msg_close( fd, n );
                }
            }
            msg_switch_destroy( fd );
            zs_close( fd );
        }
        break;
    }
}
Esempio n. 2
0
static int msg_read_buf32(msg_t *m, void *buf, uint32_t *len) {
	int r;

	r = msg_read_u32(m, len);
	if (r) 
		return r;

	r = msg_read(m, buf, *len);
	if (r)
		return r;

	return 0;
}
Esempio n. 3
0
int 	main(int argc, char **argv)
{
	t_env	e;

	if ((e.key = ftok(argv[0], 'a')) < 0)
	{
		perror("ftok");
		exit(1);
	}
	// printf("e.key : %d\n", e.key);
	if (argc == 2)
	{
		init_env(&e, argv[1]);
		while (1)
		{
			printf("ICI\n");
			op_sem_proberen(&e);
			printf("LA\n");
			// printf("heya\n");
			if ((*((int*)(e.addr + sizeof(int)))) == 0)
			{
				check_start(&e);
				op_sem_verhogen(&e);
				continue ;
			}
			printf("hey0\n");
			test_print(&e);
			if (check_elim(&e))
				player_lost(&e);
			msg_read(&e);
			printf("hey1\n");
			begin_turn(&e);
			op_sem_verhogen(&e);
			if ((*((int*)(e.addr + sizeof(int)))) == 1 && check_victory(&e))
			{
				printf("VICTOIRRRRRRRRE team : %d\n", e.team);
				kill_player(&e);
			}	
			printf("leader : %d\n", e.leader);
			usleep(500000);
		}
	}
	else
		printf("Usage : %s [team]\n", argv[0]);
	return (0);
}
Esempio n. 4
0
static int msg_read_str32(msg_t *m, char **str) {
	int r;

	uint32_t len;
	r = msg_read_u32(m, &len);
	if (r)
		return r;

	char *s = (char *)zalloc(len+1);
	r = msg_read(m, s, len);
	if (r) {
		free(s);
		return r;
	}

	*str = s;
	return 0;
}
Esempio n. 5
0
static int msg_read_allocbuf32(msg_t *m, void **_buf, uint32_t *_len) {
	int r;

	uint32_t len;
	r = msg_read_u32(m, &len);
	if (r)
		return r;

	void *buf = zalloc(len);
	r = msg_read(m, buf, len);
	if (r) {
		free(buf);
		return r;
	}

	*_buf = buf;
	*_len = len;
	return 0;
}
/*
 * Commits messages to the FIFO.  If the FIFO is full, then enough
 * messages are dropped to create space for the new message.
 */
void ipc_log_write(void *ctxt, struct encode_context *ectxt)
{
	struct ipc_log_context *ilctxt = (struct ipc_log_context *)ctxt;
	int bytes_to_write;
	unsigned long flags;

	if (!ilctxt || !ectxt) {
		pr_err("%s: Invalid ipc_log or encode context\n", __func__);
		return;
	}

	spin_lock_irqsave(&ipc_log_context_list_lock, flags);
	spin_lock(&ilctxt->ipc_log_context_lock);
	while (ilctxt->write_avail < ectxt->offset)
		msg_read(ilctxt, NULL);

	bytes_to_write = MIN(((PAGE_SIZE - sizeof(struct ipc_log_page_header))
				- ilctxt->write_page->hdr.write_offset),
				ectxt->offset);
	memcpy((ilctxt->write_page->data +
		ilctxt->write_page->hdr.write_offset),
		ectxt->buff, bytes_to_write);
	if (bytes_to_write != ectxt->offset) {
		ilctxt->write_page->hdr.write_offset = 0xFFFF;
		ilctxt->write_page = get_next_page(ilctxt, ilctxt->write_page);
		ilctxt->write_page->hdr.write_offset = 0;
		memcpy((ilctxt->write_page->data +
			ilctxt->write_page->hdr.write_offset),
		       (ectxt->buff + bytes_to_write),
		       (ectxt->offset - bytes_to_write));
		bytes_to_write = (ectxt->offset - bytes_to_write);
	}
	ilctxt->write_page->hdr.write_offset += bytes_to_write;
	ilctxt->write_avail -= ectxt->offset;
	complete(&ilctxt->read_avail);
	spin_unlock(&ilctxt->ipc_log_context_lock);
	spin_unlock_irqrestore(&ipc_log_context_list_lock, flags);
}
Esempio n. 7
0
static int run_worker(struct worker_data *data)
{
	char buf[PIPE_BUF+1] = {};
	char outbuf[PIPE_BUF+1] = {};
	char *urls[MAX_URLS];
	size_t urls_c;
	char *p;
	int res, i;
	ssize_t len;
	double bytes;
	long header_bytes;
	if(init_worker(data)) return -1;

	while(1)
	{
		if((len = msg_read(data->pipe_r, buf, sizeof(buf))) == -1) {
			return EXIT_FAILURE;
		}
		buf[len] = '\0';
		if(strncmp(buf, "STOP", 4) == 0 || len == 0) return destroy_worker(data);
		if(strncmp(buf, "RESET", 5) == 0) {
			if((res = reset_worker(data)) != 0) {
				len = sprintf(outbuf, "ERR %d", res);
				msg_write(data->pipe_w, outbuf, len);
			} else {
				msg_write(data->pipe_w, "OK", sizeof("OK"));
			}
			continue;
		}
		if(strncmp(buf, "URLLIST ", 8) == 0) {
			p = buf + 8;
			data->chunk.enabled = 1;
		} else if(strncmp(buf, "URL ", 4) == 0) {
			p = buf + 4;
		} else {
			fprintf(stderr, "Unrecognised command '%s'!\n", buf);
			break;
		}

		if(data->debug) {
			fprintf(stderr, "Getting URL '%s'.\n", p);
		}

		curl_easy_setopt(data->curl, CURLOPT_URL, p);
		data->chunk.size = 0;
		if((res = curl_easy_perform(data->curl)) != CURLE_OK) {
			len = sprintf(outbuf, "ERR %d", res);
			msg_write(data->pipe_w, outbuf, len);
		} else {
			if((res = curl_easy_getinfo(data->curl, CURLINFO_SIZE_DOWNLOAD, &bytes)) != CURLE_OK ||
				(res = curl_easy_getinfo(data->curl, CURLINFO_HEADER_SIZE, &header_bytes)) != CURLE_OK ) {
				fprintf(stderr, "cURL error: %s\n", curl_easy_strerror(res));
			}
			if(data->chunk.enabled == 0) {
				len = sprintf(outbuf, "OK %lu bytes", (long)bytes + header_bytes);
				msg_write(data->pipe_w, outbuf, len);
			} else {
				urls_c = parse_urls(data->chunk.memory, data->chunk.size, urls, MAX_URLS);
				len = sprintf(outbuf, "OK %lu bytes %lu urls", (long)bytes + header_bytes, (long)urls_c);
				msg_write(data->pipe_w, outbuf, len);
				for(i = 0; i < urls_c; i++) {
					len = sprintf(outbuf, "%s", urls[i]);
					msg_write(data->pipe_w, outbuf, len);
					free(urls[i]);
				}
				data->chunk.enabled = 0;
			}
		}
	}
	return 0;
}
Esempio n. 8
0
void * lisen()
{

	char    c;
	char    respond_code[20]  = {0};
	char    respond_code1[20] = {0};
	char    temp[20]          = {0};
	Message inbox;
	CL      r;
	char    *Num;
	int     i;
	int     tel_count;
	int     msg_count;
	FILE    *fp1;
	tty_init();
	gprs_init();  // 初識化GPRS模塊
	while (Mon_flag) {
		// memset(respond_code,0,20);
		tty_read(&c, 1);
		//printf("dds\n");
		if (c == 'R') {
			tty_read(respond_code, 3);
			respond_code[3] = '\0';
			if (strcmp(respond_code, "ING") == 0) {
				//printf("%s",respond_code);
				calltype = 2;
				SendNotifyMessage(hcwd, MSG_RING, 0, 0L);
				printf("call call ....");
			}
		}

		if (c == 'N') {   //收到掛電話
			tty_read(respond_code1, 9);
			//respond_code1[9]='\0';
			if (strcmp(respond_code1, "O CARRIER") == 0) {
				//發送消息到通話界面,結束正在通話界面,返回主界面。
				if (calltype == 1) {
					SendNotifyMessage(h_calling, MSG_USRHOLD, 0, 0L);
				} else if (calltype == 2)    {
					strcpy(r.Phone_num, PhoneNum);
					//records_write(FILE_MISSED_CALL_DAT,&r);
					SendMessage(c_holding, MSG_MISSED, 0, 0L);
				}
			}
		}

		if (c == '+') {
			tty_read(respond_code, 4);
			respond_code[4] = '\0';
			if (strcmp(respond_code, "CLIP") == 0) {
				printf("CLIP");
				for (i = 0; i < 20; i++) {
					tty_read(&c, 1);
					PhoneNum[i] = c;
				}
				PhoneNum[i] = '\0';
				Num         = (char*)strtok(PhoneNum, "\"");
				Num         = (char*)strtok(NULL, "\"");
				strcpy(temp, Num);
				strcpy(PhoneNum, temp);
				//printf("%s",Num);
			} else if (strcmp(respond_code, "CMTI") == 0)	   {
				//msg_read(Mes_index);

				tty_read(temp, 7);
				tty_read(temp, 2);
				temp[3] = '\0';
				printf(" msg index= %s ", temp);
				Mes_index = atoi(temp);
				printf(" Mes_index= %d", Mes_index);
				msg_read(Mes_index);
				SendNotifyMessage(hMainWnd, MSG_NEWMSG, 0, 0L);
			} else if (strcmp(respond_code, "CMGR") == 0)	   {
				tty_read(&c, 1);
				while (c != ',') {
					tty_read(&c, 1);
				}
				tty_read(&c, 1);
				tty_read(&c, 1);
				while (c != '\"') {
					Tel_Num[tel_count++] = c;
					tty_read(&c, 1);
				}
				Tel_Num[tel_count] = '\0';
				printf("\n- %s \n", Tel_Num);
				tty_read(temp, 3);

				tty_read(Data, 17);
				Data[17] = '\0';
				printf("\n %s\n ", Data);

				tty_read(&c, 1);
				while (c != '\n') {
					tty_read(&c, 1);
				}

				tty_read(&c, 1);
				tty_read(&c, 1);
				while (c != '\n') {
					Msg_text[msg_count++] = c;
					tty_read(&c, 1);
				}
				Msg_text[msg_count] = '\0';
				printf("\n %s ", Msg_text);
				tty_read(&c, 1);
				while (c != 'K') {
					tty_read(&c, 1);
				}

				if ((fp1 = fopen("./message/inbox.dat", "a+")) == NULL)	{
					printf("open file inbox.dat error, program ending !");
				}


				//  printf("now find the file\n");
//                                fprintf(fp1,"%d",Mes_index);


				inbox.index = Mes_index;
				memset(inbox.name, 20, 0);
				strcpy(inbox.PhoneNumber, Tel_Num);
				strcpy(inbox.Msgtime, Data);
				strcpy(inbox.Msgtext, Msg_text);

				fwrite(&inbox, sizeof(Message), 1, fp1);


				fclose(fp1);

			}



		}

	}
}
Esempio n. 9
0
int main()
{
    int fd;
    int i = TESTNUM;
    int shared_data_size = (1 * sizeof(struct shm_data));
    struct shm_data *msg;

    /* shared memory */
    fd = shm_open(SHM_PATH,
                  O_CREAT | O_RDWR,
                  S_IRWXU | S_IRWXG);
    if (fd < 0)
        err("shm_open");

    int r = ftruncate(fd, shared_data_size);
    if (r != 0)
        err("ftruncate");

    msg = (struct shm_data *) mmap(NULL, shared_data_size,
                                   PROT_WRITE, MAP_SHARED, fd, 0);
    if (msg == NULL)
        err("mmap");

    /* write cmd in shm */
    /*  while(i >= 0)
      {
        unsigned addr = (unsigned) rand() % 70;
        r = msg_write(msg, addr);
        msg_read(msg, addr, r);
        i--;
      }
    */
    char * rabbit[6];
    rabbit[0] = "bitmaps/rabbit1.bmp";
    rabbit[1] = "bitmaps/rabbit2.bmp";
    rabbit[2] = "bitmaps/rabbit3.bmp";
    rabbit[3] = "bitmaps/rabbit4.bmp";
    rabbit[4] = "bitmaps/rabbit5.bmp";
    rabbit[5] = "bitmaps/rabbit6.bmp";

    unsigned addr = (unsigned) rand() % 10;

    FILE * fp = fopen(rabbit[0], "rb");

    fseek(fp, 0L, SEEK_END);
    unsigned size = ftell(fp);

    fseek(fp, 0L, SEEK_SET);
    void * img = malloc(size+1);
    int ieee = 0;
    ieee = fread(img, size, 1, fp);
    printf("readed %d\n", ieee);
    msg_write(msg, addr, img);
    fclose(fp);
//  free(img);

    img = msg_read(msg, addr, size);
    fp = fopen("bitmaps/rabbit_0.bmp", "wb+");
    fwrite(img, size, 1,fp);
    fclose(fp);
    free(img);

    /*
      unsigned addr = (unsigned) rand() % 10;
      int idx, size;
      for (idx = 0; idx < 6; idx++)
      {
        FILE * fp = fopen(rabbit[0], "rb");

        fseek(fp, 0L, SEEK_END);
        size = ftell(fp);

        fseek(fp, 0L, SEEK_SET);
        unsigned char * img = (unsigned char *) malloc(size);
        fread(img, sizeof(unsigned char), size, fp);
        msg_write(msg, addr, img);
        fclose(fp);
        free(img);
        addr += size + 10;
      }
      FILE * fp = fopen(
      unsigned addr0 = (unsigned) rand() % 41;
      unsigned addr1 = addr0 + sizeof(bmp0) + 2;
    */



    if (shm_unlink(SHM_PATH) != 0)
        err("shm_unlink");

    return 0;
}
Esempio n. 10
0
static int msg_read_u32(msg_t *m, uint32_t *v) {
	return msg_read(m, v, 4);
}