Example #1
0
int main (int argc, char *argv[]){
  Client *client;
  char  s[MAXLINE];

  if (argc < 2){
    fprintf(stderr, "Please provide an address to connect to.\n");
    return(EXIT_FAILURE);
  }

  client = client_new();


  //connect the client to the server
  if(client_connect(client, argv[1]) == SOCKET_CONNECT_ERROR){
    fprintf(stdout, "Cannot connect to the server\n");
  }

  //create the listening thread of the client
  pthread_t t1;
  int iret1 = pthread_create(&t1, NULL, listen_thread, (void *) client);

  //sending loop
  while(true){

    while(fgets(s, MAXLINE, stdin) != NULL){
      fprintf(stdout, "Sending: %s to the client.\n", s);

      char *c;
      if ((c = strchr(s, '\n')) != NULL)
        *c = '\0';

      if(client_send(client, s) == MSG_SENT){
        fprintf(stdout, "Message sent to the server.\n");
      }
    }
  }

  return(EXIT_SUCCESS);
}
Example #2
0
void wcb_connect(EV_P_ ev_io *w, int tev)
{
	client_t *c = aux_memberof(client_t, wev_connect, w);

	if (EV_READ & tev)
	{
		fprintf(stderr, "conn error fd=%d\n", w->fd);
		client_del(c);
		return;
	}

#if 0
	int rc = client_send(c);
	if (0 > rc) return;
#endif

	c->to_send = 1;

	ev_io_stop(loop, &c->wev_connect);
	ev_io_start(loop, &c->wev_send);
	ev_io_start(loop, &c->wev_recv);
}
Example #3
0
/*** ZE CLIENT ***/
void shell(void){

    char buffer[MAX_SIZE];
    message_t msg;

    while(1){
        memset(&buffer, '\0', sizeof(buffer) + 1);
        memset(&msg,  0, sizeof(message_t));

        printf("%s", PROMPT);   
        fgets(buffer, sizeof(buffer), stdin);
        printf("DEBUG: %s\n", buffer);
        
        /* Message Decipher */
        if(0 == strncmp(buffer, CMD_ADD, strlen(CMD_ADD))){
            client_add(buffer);
            continue;
        }else if(0 == strncmp(buffer, CMD_INBOX, strlen(CMD_INBOX))){
            client_inbox(buffer);
            continue;
        }else if(0 == strncmp(buffer, CMD_READ, strlen(CMD_READ))){
            client_read(buffer);
            continue;
        }else if(0 == strncmp(buffer, CMD_SEND, strlen(CMD_SEND))){
            client_send(buffer);
            continue;
        }else if(0 == strncmp(buffer, CMD_LIST, strlen(CMD_LIST))){
            client_list(buffer);
            continue;
        }else if(0 == strncmp(buffer, CMD_ISA, strlen(CMD_ISA))){
            client_isa(buffer);
            continue;
        }


    }
}
Example #4
0
/* -------------------------------------------------------------------------- *
 * argv[0] - prefix                                                           *
 * argv[1] - 'nbounce'                                                        *
 * argv[2] - old nick/uid                                                     *
 * argv[3] - new nick                                                         *
 * argv[4] - ts                                                               *
 * -------------------------------------------------------------------------- */
static void ms_nbounce(struct lclient *lcptr, struct client *cptr,
                       int             argc,  char         **argv)
{
  struct client *acptr;

  if(lcptr->caps & CAP_UID)
    acptr = client_find_uid(argv[2]);
  else
    acptr = client_find_nick(argv[2]);

  if(acptr == NULL)
  {
    log(client_log, L_warning, "Dropping invalid NBOUNCE for user %s.",
        argv[2]);
    return;
  }

  if(client_is_local(acptr))
  {
    client_send(acptr, ":%S NOTICE %C :*** Your nick has been bounced at %C",
                server_me, acptr, cptr);
  }

  acptr->ts = str_toul(argv[4], NULL, 10);

  chanuser_send(NULL, acptr, ":%N!%U@%H NICK :%s",
                acptr, acptr, acptr, argv[3]);

  server_send(lcptr, NULL, CAP_UID, CAP_NONE,
              ":%s NBOUNCE %s %s :%u",
              cptr->name, acptr->user->uid, argv[3], acptr->ts);
  server_send(lcptr, NULL, CAP_NONE, CAP_UID,
              ":%s NBOUNCE %s %s :%u",
              cptr->name, acptr->name, argv[3], acptr->ts);

  client_set_name(acptr, argv[3]);
}
Example #5
0
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(udp_client_process, ev, data) {
	PROCESS_BEGIN()
	;

	PROCESS_PAUSE()
	;

	set_global_address();

	//	senderStartTime = get_time_ms();
	PRINTF("UDP client process started\n");

	//	print_local_addresses();

	/* new connection with remote host */
	client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL);
	udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT));

	//	PRINTF("Created a connection with the server ");
	//	PRINT6ADDR(&client_conn->ripaddr);
	//	PRINTF(" local/remote port %u/%u\n",
	//			UIP_HTONS(client_conn->lport), UIP_HTONS(client_conn->rport));
	// Initial value of nodeInf

	// Initial values
	nodeInf.sinkMinTX = 65535;
	stopCond = 0;

	static struct etimer et;

	//etimer_set(&et, CLOCK_SECOND * 1 + random_rand() % (CLOCK_SECOND * 1));

	static struct etimer periodic;
	//etimer_set(&et, 2 * CLOCK_SECOND);

	int i;
	while (1) {
//		PROCESS_YIELD();

		PROCESS_WAIT_EVENT()
		;

		/* Send a packet every 30 seconds. */
		if (etimer_expired(&periodic)) {
			i = 0;
			etimer_set(&periodic, CLOCK_SECOND * 2);
			etimer_set(&et, random_rand() % (CLOCK_SECOND * 2));
		}

		if (stopCond == 1) {
			break;
		}

		//

		if (ev == tcpip_event) {
			tcpip_handler();
		} else if (etimer_expired(&et)) {

			client_send();
		}
	}

PROCESS_END();
}
int parse_shell()
{
  char shell_input[MAX_LENGTH];
  char message[MAX_LENGTH];
  static bool is_client_connected = false;
  int ret = 0;
  static int server_sock;

  /*
   * Get the input
   */
  fgets(shell_input, MAX_LENGTH, stdin);
  if(strlen(shell_input) <= 1)
    return 0;
  shell_input[strlen(shell_input)-1] = '\0';
  strcpy(message, shell_input);

  /*
   * Tokenize the strings
   */
  char *arg;
  int argc = 0;
  char argv[4][256];
  char *temp;
  char *command = strtok_r(shell_input, " ", &temp);
  //TODO reorder all commands!!
  // ----------------Commands common for server/client ------------
  if(!strcmp("AUTHOR", command))
  {
    print_success(1, command);
    LOG("I, g8, have read and understood the course academic integrity policy.\n");
  }
  else if(!strcmp("EXIT", command))
  {
    return 1;
  }
  // -------------------Common commands ---------------------------
  else if(!is_server)
  {
    char arg_copy[MAX_LENGTH];
    if(temp!=NULL)
    {
      strcpy(arg_copy, temp);
      for(arg = strtok_r(NULL, " ", &temp); arg && argc<4; arg = strtok_r(NULL, " ", &temp))
      {
        strcpy(argv[argc], arg);
        argc++;
      }
    }
    if(!strcmp("LOGIN", command))
    {
      if(!is_server && !(is_client_connected || argc!=2) && 
          validate_ip(argv[0]) && validate_port(argv[1]))
      {
        int newfd = client_connect(argv[0], argv[1]);
        if(newfd<=1)
        {
          print_success(0, command);
        }
        else
        {
          //TODO client connects to unknown port?
          is_client_connected = true;
          add_fd(newfd);
          client_identify(newfd);
          server_sock = newfd;
          print_success(1, command);
        }
      }
      else
        print_success(0, command);
    }
    else if(is_client_connected)
    {
      if(!strcmp("PORT", command))
      {
        print_success(1, command);
        LOG("PORT:%d\n", get_listening_port());
      }
      else if(!strcmp("IP", command))
      {
        print_success(1, command);
        get_ip();
      }
      else if(!strcmp("SEND", command))
      {
        if(!is_client_connected)
          print_success(0,command);
        else
          print_success(client_send_msg(server_sock, arg_copy), command);
      }
      else if(!strcmp("SENDFILE", command))
      {
        if(argc == 2 && validate_ip(argv[0]))
        {
          print_success(1, command);
          client_send_file(argv[0], argv[1]);
        }
        else
          print_success(0, command);
      }
      else if(!strcmp("LOGOUT", command))
      {
        if(is_client_connected)
        {
          //close(server_sock);
          //clear_fd(server_sock);
          client_send(server_sock, command);
          is_client_connected  = false;
          //server_sock = -1;
          print_success(1, command);
        }
        else
          print_success(0, command);
      }
      else if(!strcmp("LIST", command))
      {
        print_success(1, command);
        print_client_list();
      }
      else if(!strcmp("REFRESH", command))
      {
        client_send(server_sock, command);
        print_success(1, command);
      }
      else if(!strcmp("BROADCAST", command))
      {
        if(argc)
        {
          client_send(server_sock, message);
          print_success(1, command);
        }
        else print_success(0, command);
      }
      else if(!strcmp("BLOCK", command))
      {
        if(argc == 1 && verify_ip(argv[0])
            && !is_client_blocked(argv[0]))
        {
          //TODO CHECK IP in list!! done!
          print_success(1, command);
          add_to_block_list(argv[0]);
          client_send(server_sock, message);
        }
        else
        {
          print_success(0, command);
        }
      }
      else if(!strcmp("UNBLOCK", command))
      {
        if(argc == 1 && verify_ip(argv[0])
            && is_client_blocked(argv[0]))
        {
          print_success(1, command);
          remove_from_block_list(argv[0]);
          client_send(server_sock, message);
        }
        else
          print_success(0, command);
      }
      else
        print_success(0, command);
    }
    else
      print_success(0, command);
  }
  else
  {
    if(!strcmp("STATISTICS", command))
    {
      print_success(1, command);
      print_stats();
    }
    else if(!strcmp("BLOCKED", command))
    {
      if(temp == NULL)
        print_success(0, command);
      else
      {
        char *ip = strtok_r(NULL, " ", &temp);
        if(validate_ip(ip) && find_client_by_ip(ip) !=NULL)
        {
          print_success(1, command);
          print_blocked_clients(ip);
        }
        else
          print_success(0, command);
      }
    }
    else if(!strcmp("LIST", command))
    {
      print_success(1, command);
      print_connected_client_list();
    }
    else if(!strcmp("PORT", command))
    {
      print_success(1, command);
      LOG("PORT:%d\n", get_listening_port());
    }
    else if(!strcmp("IP", command))
    {
      print_success(1, command);
      get_ip();
    }
    else
      print_success(0, command);
  }

  LOG("[%s:END]\n", command);
  return 0;
}
Example #7
0
int client_main(int argc, char **argv) {
	if (argc < 4) {
		fprintf(stderr, "Usage: wetalk -c <ip> <uid> <password>\n"
						"Or   : wetalk -r <ip> <username> <password>\n");
		return wetalk_usage("wetalk");
	}

	int uid = 0;
	char *ipaddr = argv[1];
	char *password = argv[3];

	if (strlen(password) >= PASSWORD_MAX) {
		fprintf(stderr, "错误的密码长度\n");
		return 1;
	}

	if (!client_init(argv[1], on_msg_recv)) {
		wetalk_error("初始化客户端失败\n");
	}

	if (!strcmp(argv[0], "-r")) {
		uid = client_register(argv[2], password);
		if (uid > 0) {
			fprintf(stderr, "注册成功,您的 uid 为: %d\n这是以后登陆时必要的信息,请牢记\n回车键以继续", uid);
			getchar();
		} else {
			fprintf(stderr, "注册失败\n");
			return 1;
		}
	} else {
		uid = atoi(argv[2]);
		if (uid <= 0) {
			fprintf(stderr, "错误的uid\n");
			return 1;
		}
	}

	if (!client_login(uid, password)) {
		wetalk_error("登陆失败\n");
	}

	client_main_run = true;
	int r;

	setlocale(LC_ALL, "");
	initscr();
	getmaxyx(stdscr, window_y, window_x);

	char input[BUFFER_SIZE] = {0};
	while(client_main_run) {
		draw_editarea();

		getnstr(input, BUFFER_SIZE - 1);
		r = strlen(input);
		input[r] = '\0';

		if (r > 0) {
			client_send(input);
		}
	}

	endwin();
	return 0;
}
Example #8
0
void		player_look_end_cb(t_client *client, int error)
{
  (void)error;
  client_send(client, REP_KO);
}
Example #9
0
	bool slw::client_send(unsigned char uType, int p1, int p2)
	{
		return client_send(uType, p1, p2, NULL, 0);
	}
Example #10
0
/****************************************************************************
  Message Handler: submit_job_*(func, uniq, arg)
 ****************************************************************************/
int msg_submit_job(Client *cli, unsigned char *arg, int argsize, gboolean background, gboolean high)
{
    unsigned char *args[3];
    int last_arg_len = parse_args(args, 3, arg, argsize);

    int is_uniq = args[1][0] != 0;

    const gchar *func = g_intern_string((char*)args[0]);
    // printf(">> [%s] = %.8x\n", args[0], func);

    /* look for a duplicate job - if one exists, add to listeners */
    if (is_uniq) {
        UniqJobKey uk;
        uk.func = func;
        if (args[1][0] == '-' && args[1][1] == 0) {
            uk.uniq = args[2];
            uk.uniq_len = last_arg_len;
        } else {
            uk.uniq = args[1];
            uk.uniq_len = strlen((char*)args[1]);
        }
        Job *job = g_hash_table_lookup(g_uniq_jobs, &uk);
        if (job) {
            #if DEBUG
            g_debug("[%s] submit_job - merging %s:%s -> %s", cli->id, job->func, job->uniq, job->handle);
            #endif
            if (!job->background) {
                g_ptr_array_add_uniq(job->listeners, cli);
                client_listen_to(cli, job);
            }
            MemBlock *block = new_response(MSG_JOB_CREATED, strlen(job->handle), (unsigned char *)job->handle);
            client_send(cli, block);
            return 0;
        }
    }

    Job *job = job_new();
    generate_job_handle(job->handle);
    job->func = func;
    if (last_arg_len == 0)
        job->arg = (unsigned char *)"";
    else {
        job->arg = malloc(last_arg_len);
        memcpy(job->arg, args[2], last_arg_len);
    }
    job->arg_len = last_arg_len;
    job->background = background;
    if (!background) {
        g_ptr_array_add(job->listeners, cli);
    }
    g_hash_table_insert(g_jobs, job->handle, job);

    #if DEBUG
    g_debug("[%s] submit_job: %s, %s -> %s", cli->id, args[0], args[1], job->handle);
    #endif

    jobqueue_push(g_jobqueue, job, high);
    if (!background) {
        client_listen_to(cli, job);
    }

    job->is_uniq = is_uniq;
    if (is_uniq) {
        job->uniq = strdup((char*)args[1]);
        job->uniq_key.func = func;
        if (job->uniq[0] == '-' && job->uniq[1] == 0) {
            job->uniq_key.uniq = job->arg;
            job->uniq_key.uniq_len = job->arg_len;
        } else {
            job->uniq_key.uniq = (unsigned char *)job->uniq;
            job->uniq_key.uniq_len = strlen(job->uniq);
        }
        g_hash_table_insert(g_uniq_jobs, &job->uniq_key, job);
        #if DEBUG
        g_debug("[%s] \tadded uniq job %s", cli->id, job->handle);
        #endif
    }

    MemBlock *block = new_response(MSG_JOB_CREATED, strlen(job->handle), (unsigned char *)job->handle);
    client_send(cli, block);
    wake_up_sleepers(job->func);

    return 0;
}
Example #11
0
/**
 * 和客户交互
 * @param  sockfd [description]
 * @param  i      [description]
 * @return        [description]
 */
int client_interface(struct bufferevent *bev, client_t *client) {
    /*加锁*/
    if (pthread_mutex_lock(&mutex) != 0) {
        perror("pthread_mutex_lock");
        exit(EXIT_FAILURE);
    }

    char data[4096];
    int nbytes;

    //接收数据
    char buffer[MAX_BUF + 1];
    bzero(buffer, MAX_BUF + 1);
    int n = 0;
    int str_len = 0;
    int last_len;
    while ((nbytes = EVBUFFER_LENGTH(bev->input)) > 0) {
        if (nbytes > 4096) nbytes = 4096;
        n += evbuffer_remove(bev->input, data, nbytes);
        str_len = strlen(data);
        last_len = (MAX_BUF - strlen(buffer));
        if (last_len >= str_len) {
            strncat(buffer, data, str_len);
        } else {
            strncat(buffer, data, last_len);
        }
    }

    if (n <= 0) {
        /*解锁锁*/
        if (pthread_mutex_unlock(&mutex) != 0) {
            perror("pthread_mutex_unlock");
            exit(EXIT_FAILURE);
        }

        return 0; //客户端退出时
    }

    //printf("第%d个客户端 IP:%s\n", i + 1, inet_ntoa(_client[i].addr.sin_addr));

    //解析客户端信息
    int flag = 0;

    int ret;
    char key[20];
    sprintf(key, "%d", client->fd);
    client_elem *c_el;
    ret = hashmap_get(client_map, key, (void **)&c_el);
    assert(ret == HMAP_S_OK);

    _RTS_TRANSPORT_DATA _rts_transport_data;
    _rts_transport_data = RTS_transport_data_init();
    if (RTS_transport_data_parse(buffer, &_rts_transport_data) == 0) {
        client_send(client, "{\"code\":\"0001\",\"message\":\"数据格式非法\"}");

        /*解锁锁*/
        if (pthread_mutex_unlock(&mutex) != 0) {
            perror("pthread_mutex_unlock");
            exit(EXIT_FAILURE);
        }

        return 0;
    }

    if (!_rts_transport_data.action) {
        client_send(client, "{\"code\":\"0005\",\"message\":\"参数非法\"}");

        /*解锁锁*/
        if (pthread_mutex_unlock(&mutex) != 0) {
            perror("pthread_mutex_unlock");
            exit(EXIT_FAILURE);
        }

        return 0;
    }

    if (strcmp(_rts_transport_data.action, "login") == 0) { //登录
        if (strlen(_rts_transport_data.name) == 0 || strlen(_rts_transport_data.password) == 0) {
            client_send(client, "{\"code\":\"0005\",\"message\":\"参数非法\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 0;
        }

        //验证用户名密码
        _RTS_USER *_rts_user = user_get(0, _rts_transport_data.name);
        if (_rts_user->id <= 0) {
            client_send(client, "{\"code\":\"0003\",\"message\":\"用户名或密码错误\"}");
            CLIENT_FREE(_rts_user);

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 0;
        }

        char *pwdhash = RTS_hash(_rts_transport_data.password, _rts_user->salt);

        if (strcmp(_rts_user->password, pwdhash) != 0) {
            client_send(client, "{\"code\":\"0003\",\"message\":\"用户名或密码错误\"}");
            CLIENT_FREE(pwdhash);
            CLIENT_FREE(_rts_user);

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 0;
        }

        //用户名密码验证通过后,判断当前账号是否已登录
        //这时应该已经拿到了用户的id
        if (c_el->token && strlen(c_el->token) > 0) { //该设备已经登录了账号,不能再做登录操作
            client_send(client, "{\"code\":\"1004\",\"message\":\"该设备已经登录了账号,不能再做登录操作\"}");
            CLIENT_FREE(pwdhash);
            CLIENT_FREE(_rts_user);

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 1;
        }

        if (c_el->id == 0 || (c_el->token && strlen(c_el->token) == 0)) { //未登录,直接执行登录赋值操作
            //登录成功,返回认证标示
            char *unique = RTS_unique();
            strncpy(_rts_transport_data.token, unique, MAX_TOKEN_LENGTH);
            CLIENT_FREE(unique);

            //重新设置client_map
            ret = hashmap_remove(client_map, c_el->key, (void **)&c_el);
            assert(ret == HMAP_S_OK);
            client_elem *new_c_el = (client_elem *)malloc(sizeof(client_elem));
            sprintf(new_c_el->key, "%d", client->fd);
            new_c_el->addr = c_el->addr;
            new_c_el->client = client;
            new_c_el->id = _rts_user->id;
            new_c_el->name = (char *)malloc(MAX_NAME_LENGTH + 1);
            strncpy(new_c_el->name, _rts_transport_data.name, MAX_NAME_LENGTH);
            new_c_el->token = (char *)malloc(MAX_TOKEN_LENGTH + 1);
            strncpy(new_c_el->token, _rts_transport_data.token, MAX_TOKEN_LENGTH);
            free_client_elem(c_el, 0);
            ret = hashmap_put(client_map, new_c_el->key, new_c_el);
            assert(ret == HMAP_S_OK);

            //设置client_id_map
            client_id_elem *cid_el = (client_id_elem *)malloc(sizeof(client_id_elem));
            sprintf(cid_el->key, "%d", _rts_user->id);
            cid_el->fd = client->fd;
            ret = hashmap_put(client_id_map, cid_el->key, cid_el);
            assert(ret == HMAP_S_OK);

            RTS_printf("[++登录成功++]: NAME:%s--IP:%s\n", _rts_transport_data.name, inet_ntoa(c_el->addr.sin_addr));
            bzero(buf, MAX_BUF + 1);
            sprintf(buf, "{\"code\":\"0000\",\"message\":\"登录成功\",\"token\":\"%s\",\"id\":%d}", _rts_transport_data.token, _rts_user->id);
            client_send(client, buf);

            //修改登录成功标识
            _RTS_USER _rts_user2 = user_init();
            _rts_user2.id = _rts_user->id;
            _rts_user2.status = 1;
            user_edit(_rts_user2);

            CLIENT_FREE(pwdhash);
            CLIENT_FREE(_rts_user);

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 1;
        }

        client_send(client, "{\"code\":\"1003\",\"message\":\"该用户已经在其他地方成功登录\"}");
        CLIENT_FREE(pwdhash);
        CLIENT_FREE(_rts_user);

        /*解锁锁*/
        if (pthread_mutex_unlock(&mutex) != 0) {
            perror("pthread_mutex_unlock");
            exit(EXIT_FAILURE);
        }

        return 1;

    }

    if (strcmp(_rts_transport_data.action, "message") == 0) { //聊天
        if (strlen(_rts_transport_data.token) == 0 || !_rts_transport_data.toid || !_rts_transport_data.id || wcslen(_rts_transport_data.content) == 0) {
            client_send(client, "{\"code\":\"0005\",\"message\":\"参数非法\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 0;
        }

        //认证信息失败,退出客户端
        if (!c_el->token || (strcmp(_rts_transport_data.token, "bsh_test_$%1KP@'") != 0 && strcmp(_rts_transport_data.token, c_el->token) != 0)) {
            client_send(client, "{\"code\":\"0004\",\"message\":\"token非法\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 0;
        }

        //判断登录者身份
        if (!c_el->id || c_el->id != _rts_transport_data.id) {
            client_send(client, "{\"code\":\"0006\",\"message\":\"用户身份非法\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 0;
        }

        bzero(key, 20);
        sprintf(key, "%d", _rts_transport_data.toid);
        client_id_elem *cid_el;
        ret = hashmap_get(client_id_map, key, (void **)&cid_el);
        

        printf("发给id:%s\n", key);
        if (ret == 0) {
            printf("get_toid:%s ret:%d fd:%d\n", key, ret, cid_el->fd);
        }
        if (ret == HMAP_E_NOTFOUND || !cid_el || !cid_el->fd) {
            client_send(client, "{\"code\":\"1002\",\"message\":\"对方不在线\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 1;
        }

        bzero(key, 20);
        sprintf(key, "%d", cid_el->fd);
        client_elem *to_c_el;
        ret = hashmap_get(client_map, key, (void **)&to_c_el);
        assert(ret == HMAP_S_OK);

        if (to_c_el->id == _rts_transport_data.id) { //如果接受者是自己,则发出警告
            client_send(client, "{\"code\":\"1001\",\"message\":\"不能给自己发消息\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 1;
        }

        bzero(buf, MAX_BUF + 1);
        sprintf(buf, "{\"code\":\"0000\",\"message\":\"发送成功\",\"content\":\"%ls\"}", _rts_transport_data.content);
        client_send(to_c_el->client, buf);

        /*解锁锁*/
        if (pthread_mutex_unlock(&mutex) != 0) {
            perror("pthread_mutex_unlock");
            exit(EXIT_FAILURE);
        }

        return 1;
    }

    if (strcmp(_rts_transport_data.action, "logout") == 0) { //logout
        if (strlen(_rts_transport_data.token) == 0 || !_rts_transport_data.id) {
            client_send(client, "{\"code\":\"0005\",\"message\":\"参数非法\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 0;
        }

        //判断登录者身份
        if (!c_el->id || c_el->id != _rts_transport_data.id) {
            client_send(client, "{\"code\":\"0006\",\"message\":\"用户身份非法\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 0;
        }

        //认证信息失败,退出客户端
        if (c_el->token && strcmp(_rts_transport_data.token, c_el->token) != 0) {
            client_send(client, "{\"code\":\"0004\",\"message\":\"token非法\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 0;
        }

        client_send(client, "{\"code\":\"0000\",\"message\":\"退出成功\"}");

        /*解锁锁*/
        if (pthread_mutex_unlock(&mutex) != 0) {
            perror("pthread_mutex_unlock");
            exit(EXIT_FAILURE);
        }

        return 0;
    }

    if (strcmp(_rts_transport_data.action, "register") == 0) {
        if (strlen(_rts_transport_data.name) == 0 || strlen(_rts_transport_data.password) == 0) {
            client_send(client, "{\"code\":\"0005\",\"message\":\"参数非法\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 0;
        }

        char *salt = RTS_rand();
        char *pwdhash = RTS_hash(_rts_transport_data.password, salt);
        char *datetime = RTS_current_datetime();
        _rts_transport_data.id = user_add(_rts_transport_data.name, pwdhash, salt, inet_ntoa(c_el->addr.sin_addr), datetime, 0);
        CLIENT_FREE(salt);
        CLIENT_FREE(pwdhash);
        CLIENT_FREE(datetime);

        if (_rts_transport_data.id == 0) {
            client_send(client, "{\"code\":\"1005\",\"message\":\"注册失败,该用户名已注册\"}");

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 1;
        }

        if (_rts_transport_data.id > 0) {
            bzero(buf, MAX_BUF + 1);
            sprintf(buf, "{\"code\":\"0000\",\"message\":\"注册成功\",\"id\":%d}", _rts_transport_data.id);
            client_send(client, buf);

            /*解锁锁*/
            if (pthread_mutex_unlock(&mutex) != 0) {
                perror("pthread_mutex_unlock");
                exit(EXIT_FAILURE);
            }

            return 1;
        }

        client_send(client, "{\"code\":\"0007\",\"message\":\"注册失败,未知错误\"}");

        /*解锁锁*/
        if (pthread_mutex_unlock(&mutex) != 0) {
            perror("pthread_mutex_unlock");
            exit(EXIT_FAILURE);
        }

        return 1;
    }

    client_send(client, "{\"code\":\"0002\",\"message\":\"动作非法\"}");

    /*解锁锁*/
    if (pthread_mutex_unlock(&mutex) != 0) {
        perror("pthread_mutex_unlock");
        exit(EXIT_FAILURE);
    }

    return 0;
}
Example #12
0
static void send_prompt(int cfd)
{
	const char msg[] = "\n> ";

	client_send(cfd, msg, sizeof(msg) - 1);
}
Example #13
0
/**
 * Look at the current room
 * @param response message following action command
 * @param user User making action request
 * @param manager Global resource manager
 */
void *action_look( const char *response, User user, Management manager) {

    user_lock( user );
	
	Room current = char_get_room( user->parent->character );
	if( current == NULL ){
	    client_send( user->client, "You do not appear to be anywhere\n");
	}
	
	// get login
	int desc_length = 2048;
	char *desc = malloc( desc_length );
	
	// init
	memset( desc, 0, desc_length );
	
    int len = room_get_full_description( 
        current,
        user,
        &desc,
        &desc_length );

	// send the login screen
	client_send( user->client, desc );
	
	
	// loop over exits
	LinkedList link = room_get_exits( current );
	
	int shown = 0;
	
    while( link != NULL ){
        
        Exit exit = (Exit) link->data;
        
        // if not hidden
        if( exit_is_hidden( exit ) == 0 ) {
        
            const char *exit_name = exit_get_dir_text( exit );
            
            if( exit_name != NULL ){
                
                if( shown > 0 )
                    client_send( user->client, (char *)"," );
                
                shown = 1;
                client_send( user->client, (char *)exit_name );
            }
        }
        
        link = next_linked_item( link );
        
    }
	
	if( shown > 0 )
	    client_send( user->client, (char *)"\n" );

	// free up the buffer
	if( desc != NULL ){
		free( desc );
	}
	
	user_unlock( user );
	return NULL;
}
Example #14
0
int run_client(uint16_t port, vpn_conf_t *my)
{
    fd_set fds;
    int r, fd = 0, ppp = 0;
    struct in_addr out;
    struct sockaddr_in s;
    char temp[VPN_PACKET];
    
    if(vpn_cryptinit(&cry, my->algo, my->srckey, my->dstkey) == -1)
        return -1;

    signal(SIGHUP,  SIG_IGN);
    signal(SIGPIPE, SIG_IGN);

    if((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        xmsg(0, VPN_DEBUG|VPN_INFO, "socket: %s\n", errstr);
        vpn_cryptfinish(&cry);
        exit(1);
    }

    if(!inet_aton(my->dstaddr, &out)) {
        xmsg(0, VPN_DEBUG|VPN_INFO, "invalid IP address: %s\n", my->dstaddr);
        vpn_cryptfinish(&cry);
        exit(1);
    }

    /* connect */
    s.sin_family = AF_INET;
    s.sin_port   = port;
    s.sin_addr   = out;
    if(connect(fd, (struct sockaddr *)&s, sizeof(s)) == -1) {
        close(fd);
        vpn_cryptfinish(&cry);
        return xmsg(-1, VPN_DEBUG|VPN_INFO, 
                "connect (%s): %s\n", my->name, errstr);
    }

    /* set O_NONBLOCK, KEEPALIVE and TCP_NODELAY */
    sockattr(fd);
    
    /* send VPN name */
    memset(temp, 0, sizeof(temp));
    snprintf(temp, sizeof(temp), "%s\n", my->name);
    send(fd, temp, strlen(temp), 0);

    /* xmsg(0, VPN_TERM, "connected to %s, running pppd\n", my->name); */

    /* run pppd */
    if((ppp = run_pppd(my->ppplocal, my->pppremote, &pppd_pid)) == -1) {
        close(fd);
        vpn_cryptfinish(&cry);
        return xmsg(-1, VPN_DEBUG|VPN_INFO, "unable to start pppd\n");
    } else
        xmsg(0, VPN_INFO, "connected to %s\n", my->name);

    /* save pidfile */
    save_pidfile(my->name);
    
    /* set signals */
    signal(SIGINT,  mysig);
    signal(SIGTERM, mysig);
    signal(SIGKILL, mysig);
    signal(SIGSEGV, mysig);

    for(;;) {
        FD_ZERO(&fds);
        FD_SET(fd, &fds);
        FD_SET(ppp, &fds);

        if(select(ppp+1, &fds, 0, 0, 0) >= 1) {
            memset(temp, 0, sizeof(temp));
            if(FD_ISSET(fd, &fds)) {
                if((r = client_recv(fd, &cry, temp, sizeof(temp))) >= 1)
                    write(ppp, temp, r);
                else {
                    /* received invalid packet or peer disconnected 
                     * kill pppd */
                    kill(pppd_pid, SIGTERM);
                    break;
                }
            } else
            if(FD_ISSET(ppp, &fds)) {
                r = read(ppp, temp, sizeof(temp));
                if(r == -1 && (errno == EAGAIN || errno == EWOULDBLOCK))
                    continue;
                else
                if(r <= 0) {
                    xmsg(0, VPN_DEBUG|VPN_INFO, "lost pppd connection\n");
                    break;
                }

                client_send(fd, &cry, temp, r);
            }
        } else
            break;

        /* run `up' command */
        if(!ifup) {
            if(!run_cmd(my->cmdup, my->ppplocal)) {
                my_ptr = my;
                ifup = 1;
            }
        }
    }

    if(fd) close(fd);
    if(ppp) close(ppp);
    vpn_cryptfinish(&cry);

    /* run downcmd */
    if(ifup) {
        run_cmd(my->cmddown, NULL);
        ifup = 0;
    }

    return 0;
}
Example #15
0
void broadcast(char *data, size_t len) {
    struct list *tmp;
    for(tmp = clients; tmp; tmp = tmp->next) {
        client_send(tmp->c, data, len);
    }
}
Example #16
0
void*
client_request_get (void *arg) {
    r = (struct client_request *) arg;
    struct daemon_list  *d_list;
    struct daemon_list  *list_item_to_delete;
    struct daemon       *next_d;
    int                 seeder_count;
    
    if (!r)
        return NULL;


    /* First we find the file in the cache */
    
    if (find_file () < 0)
        return NULL;
    /* file_to_dl should now be the good one */


    /* Find the daemons owning the file by checking its IP */
    if ((d_list = find_daemons ()) != NULL) {
        if (client_send (r->client,
            " < no seeder for the requested file. Former seeders must have been disconnected.\n") < 0)
            log_failure (log_file, "cr_get: client_send () failed");
        return NULL;
    }

    
    /* about handling multi-seeders and block-by-block download */
    
    // we know the number of seeders
    seeder_count = d_list->id;
    
    /* FIXME : calculate smartly the blocks to consider,
     * given :
     * - number of seeders
     * - size of file to dl
     * - a max_size for a block ? Not implemented
     */
     
    /* loop where we have to post a job for each seeder
     */
    next_d = d_list->daemon;
    while (next_d != NULL) {
        // FIXME : act !!!! do something !!!
        
        list_item_to_delete = d_list;
        d_list = d_list->next;
        free (list_item_to_delete);
    }



    /* Sending the "get key begin end" message */
    sprintf (answer,
             "get %s %d %ld\n",
             file_to_dl->key,
             0,
             file_to_dl->size);
    if (daemon_send (d, answer) < 0) {
        log_failure (log_file, "cr_get: could not send the get command");
        return NULL;
    }
    
    
/* FIXME */
#if 0
    sem_wait (&downloads_lock);
    char *full_path;
    struct dl_file *f;

    full_path = malloc (strlen (prefs->shared_folder)
                        + strlen (file_to_dl->filename) + 2);
    if (!full_path) {
        log_failure (log_file, "OMG NO MALLOC IS POSSIBLE");
        return NULL;
    }
    else {
        sprintf (full_path, "%s/%s",
                        prefs->shared_folder, file_to_dl->filename);
    }
    f = dl_file_new (full_path);
    if (!f) {
        log_failure (log_file, "SHARED FOLDER : %S", prefs->shared_folder);
        log_failure (log_file, "f was NULL %s", full_path);
    }
    downloads = dl_file_add (downloads, f);
    if (!downloads)
        log_failure (log_file, "downlaods was NULL");
    else
        log_failure (log_file, "downloads->path : %s", downloads->path);
    sem_post (&downloads_lock);
#endif

    return NULL;
}
Example #17
0
int send_email(int socket,char *from,char *address,char *subject,char *content){
	char message[BUFSIZ] = "";
	char *content_encode = NULL;

	strcpy(message,"MAIL FROM: <");
	strcat(message,from);
	strcat(message,">");
	client_send(socket,message);
	get_response(socket,message,BUFSIZ);
	printf("%s\n",message);

	strcpy(message,"RCPT TO: <");
	strcat(message,address);
	strcat(message,">");
	client_send(socket,message);
	get_response(socket,message,BUFSIZ);
	printf("%s\n",message);

	client_send(socket,"DATA");
	get_response(socket,message,BUFSIZ);
	printf("%s\n",message);

	strcpy(message,"From: ");
	strcat(message,from);
	client_send(socket,message);

	strcpy(message,"To: ");
	strcat(message,address);
	client_send(socket,message);

	strcpy(message,"Subject:");
	strcat(message,subject);
	client_send(socket,message);

	client_send(socket,"MIME-Version:1.0");
	
	client_send(socket,"Content-Type:multipart/alternative;");
	client_send(socket,"boundary=----=smtp_demo");
	client_send(socket,"\r\n----=smtp_demo");


	client_send(socket,"Content-Type:text/plain;charset=utf-8");
	client_send(socket,"Content-Transfer-Encoding: 8bit\r\n");
	client_send(socket,content);
	client_send(socket,"\r\n----=smtp_demo");

	client_send(socket,"Content-Type:text/html;charset=utf-8");
	client_send(socket,"Content-Transfer-Encoding: 8bit\r\n");
	client_send(socket,content);
	client_send(socket,"\r\n----=smtp_demo");
	client_send(socket,".");
	memset(message,0,BUFSIZ);
	get_response(socket,message,BUFSIZ);
	printf("%s\n",message);
}
/**
 * Function that can be used by the transport service to transmit
 * a message using the plugin.   Note that in the case of a
 * peer disconnecting, the continuation MUST be called
 * prior to the disconnect notification itself.  This function
 * will be called with this peer's HELLO message to initiate
 * a fresh connection to another peer.
 *
 * @param cls closure
 * @param session which session must be used
 * @param msgbuf the message to transmit
 * @param msgbuf_size number of bytes in 'msgbuf'
 * @param priority how important is the message (most plugins will
 *                 ignore message priority and just FIFO)
 * @param to how long to wait at most for the transmission (does not
 *                require plugins to discard the message after the timeout,
 *                just advisory for the desired delay; most plugins will ignore
 *                this as well)
 * @param cont continuation to call once the message has
 *        been transmitted (or if the transport is ready
 *        for the next transmission call; or if the
 *        peer disconnected...); can be NULL
 * @param cont_cls closure for cont
 * @return number of bytes used (on the physical network, with overheads);
 *         -1 on hard errors (i.e. address invalid); 0 is a legal value
 *         and does NOT mean that the message was not transmitted (DV)
 */
static ssize_t
http_plugin_send (void *cls,
                  struct Session *session,
                  const char *msgbuf, size_t msgbuf_size,
                  unsigned int priority,
                  struct GNUNET_TIME_Relative to,
                  GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
{
  struct Plugin *plugin = cls;
  struct HTTP_Message *msg;
  struct Session *tmp;
  size_t res = -1;

  GNUNET_assert (plugin != NULL);
  GNUNET_assert (session != NULL);

  /* lookup if session is really existing */
  tmp = plugin->head;
  while (tmp != NULL)
  {
    if ((tmp == session) &&
       (0 == memcmp (&session->target, &tmp->target, sizeof (struct GNUNET_PeerIdentity))) &&
       (session->addrlen == tmp->addrlen) &&
       (0 == memcmp (session->addr, tmp->addr, tmp->addrlen)))
      break;
    tmp = tmp->next;
  }
  if (tmp == NULL)
  {
    GNUNET_break_op (0);
    return res;
  }

  /* create new message and schedule */
  msg = GNUNET_malloc (sizeof (struct HTTP_Message) + msgbuf_size);
  msg->next = NULL;
  msg->size = msgbuf_size;
  msg->pos = 0;
  msg->buf = (char *) &msg[1];
  msg->transmit_cont = cont;
  msg->transmit_cont_cls = cont_cls;
  memcpy (msg->buf, msgbuf, msgbuf_size);

  reschedule_session_timeout (session);

  if (session->inbound == GNUNET_NO)
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
                     "Using outbound client session %p to send to `%s'\n", session,
                     GNUNET_i2s (&session->target));
    client_send (session, msg);
    res = msgbuf_size;
  }
  if (session->inbound == GNUNET_YES)
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
                     "Using inbound server %p session to send to `%s'\n", session,
                     GNUNET_i2s (&session->target));
    server_send (session, msg);
    res = msgbuf_size;
  }
  return res;

}
Example #19
0
void*
daemon_request_file (void* arg) {
    struct daemon_request   *r;
    struct parsed_cmd       *pcmd;
    struct client           *lister;
    char                    error_buffer[BUFFSIZE];

    r = (struct daemon_request *) arg;
    if (!r)
        return NULL;

    /*
     * First, did someone asked "list"?
     */
    lister = list_client;
    if (!lister)
        return NULL;

    /*
     * cmd is supposedly:
     * file NAME KEY SIZE IP:PORT
     *  0    1    2   3      4
     */
    if (cmd_parse_failed ((pcmd = cmd_parse (r->cmd, NULL)))) {
        sprintf (error_buffer,
                 "error %s: Command parse failed",
                 __FUNCTION__);
        daemon_send (r->daemon, error_buffer);
        return NULL;
    }
    if (pcmd->argc < 5) {
        cmd_parse_free (pcmd);
        sprintf (error_buffer,
                 "error %s: Invalid number of arguments",
                 __FUNCTION__);
        daemon_send (r->daemon, error_buffer);
        return NULL;
    }

    /*
     * Hackety hack:
     * IP:PORT\0   ->   IP\0PORT\0
     */
    char *port = strchr (pcmd->argv[4], ':');
    *port = '\0';
    port++;
    file_cache = file_cache_add (file_cache,
                                pcmd->argv[1],
                                pcmd->argv[2],
                                atol (pcmd->argv[3]),
                                pcmd->argv[4],
                                atoi (port));
    cmd_parse_free (pcmd);
    char *answer = (char *)malloc ((strlen (r->cmd) + 5) * sizeof (char));
    sprintf (answer,
            " < %s\n",
            r->cmd);
    client_send (lister, answer);
    free (answer);

    return NULL;
}
Example #20
0
static void login_ask_username(client *c)
{
	const char msg[] = "username: ";

	client_send(c, msg, sizeof(msg) - 1);
}
Example #21
0
/* -------------------------------------------------------------------------- *
 * argv[0] - prefix                                                           *
 * argv[1] - 'dump'                                                           *
 * argv[2] - [server]                                                         *
 * argv[3] - module                                                           *
 * argv[4] - handle                                                           *
 * -------------------------------------------------------------------------- */
static void mo_dump(struct lclient *lcptr, struct client *cptr,
                    int             argc,  char         **argv)
{
  size_t         i;
  struct dlog   *ldptr;

  if(argc > 2)
  {
    if(argc == 3)
    {
      if(server_relay_maybe(lcptr, cptr, 2, ":%C DUMP %s", &argc, argv))
        return;
    }
    else if(argc == 4)
    {
      if(server_relay_maybe(lcptr, cptr, 2, ":%C DUMP %s %s", &argc, argv))
        return;
    }
    else if(argc == 5)
    {
      if(server_relay_always(lcptr, cptr, 2, ":%C DUMP %s %s %s", &argc, argv))
        return;
    }
  }

  if(argc == 2)
  {
    uint32_t sz;

    client_send(cptr, ":%S NOTICE %C :modules available to dump:",
                server_me, cptr);

    sz = (sizeof(m_dump_table) / sizeof(m_dump_table[0])) - 1;

    for(i = 0; i + 4 < sz; i += 4)
      client_send(cptr, ":%S NOTICE %C :%-10s %-10s %-10s %-10s",
                  server_me, cptr,
                  m_dump_table[i + 0].name,
                  m_dump_table[i + 1].name,
                  m_dump_table[i + 2].name,
                  m_dump_table[i + 3].name);

    if(sz - i == 3)
      client_send(cptr, ":%S NOTICE %C :%-10s %-10s %-10s",
                  server_me, cptr,
                  m_dump_table[i + 0].name,
                  m_dump_table[i + 1].name,
                  m_dump_table[i + 2].name);
    else if(sz - i == 2)
      client_send(cptr, ":%S NOTICE %C :%-10s %-10s",
                  server_me, cptr,
                  m_dump_table[i + 0].name,
                  m_dump_table[i + 1].name);
    else if(sz - i == 1)
      client_send(cptr, ":%S NOTICE %C :%-10s",
                  server_me, cptr,
                  m_dump_table[i + 0].name);
    return;
  }

  for(i = 0; m_dump_table[i].name; i++)
  {
    if(!str_icmp(m_dump_table[i].name, argv[2]))
    {
      ldptr = log_drain_callback(m_dump_callback,
                                 log_sources[m_dump_table[i].sp()].flag,
                                 L_debug, cptr);

      m_dump_table[i].cb(argv[3]);

      log_drain_delete(ldptr);
    }
  }
}
Example #22
0
static void login_ask_password(client *c)
{
	const char msg[] = "password: ";

	client_send(c, msg, sizeof(msg) - 1);
}
Example #23
0
void pthread_receive_from_tty()
{
	int fd;
	int nread;
	int i = 0;
	char buff[500];
	char *pbuf;
	char *dev = "/dev/ttyUSB0";
	int baud = 9600;

	DBG("\ninit tty begins\n");
	fd = tty_open_dev(dev);
	if(fd == -1)
	{
		DBG("\nOpen dev failed\n");
		exit(-1);
	}
	DBG("\nopen success\n");

	if(tty_set_speed(fd, baud) != 0)
	{
		DBG("\nSet speed failed\n");
		exit(-1);
	}
	DBG("\nset speed success\n");

	if(tty_set_parity(fd, 8, 1, 'N') != 0)
	{
		DBG("\nSet parity failed\n");
	}
	DBG("\nset parity success\n");

	_tty_fd = fd;

	while(1)
	{
		pbuf = buff;		//reset the pbuf point to the beginning of buff
		int n;
		while(1)
		{
			n = read(fd, pbuf, 1);
			if(*pbuf++ == '$')
			{
				*pbuf = '\0';
				break;
			}
		}
		printf("%s, the size is %ld\n", buff, pbuf - buff);

		if(is_ack_msg(buff, pbuf - buff))	//if this is an ACK message, read another message 
		{
			send_sockfd = find_client_to_send(head_message, buff, strlen(buff));
			pbuf = buff;		//reset the pbuf point to the beginning of buff
			while(1)
			{
				read(fd, pbuf, 1);
				if(*pbuf++ == '$')
				{
					*pbuf = '\0';
					break;
				}
			}
			//send to client
			int vv = client_send(send_sockfd, buff, strlen(buff));

			printf("second time: %s, the size is %ld\n", buff, pbuf - buff);
			printf("second time: %d, the send_sockfd is %d\n", vv, send_sockfd);

			pthread_mutex_lock(&mutex_head_message);	//lock the gloable variable head_message
			message_delete(head_message, send_sockfd);
			pthread_mutex_unlock(&mutex_head_message);	//unlock the gloable variable head_message
		}
	}
}
Example #24
0
void client_prompt(client *c)
{
	const char msg[] = "> ";

	client_send(c, msg, sizeof(msg) - 1);
}