void ser_init() {
    serfd = connect_server();
    if (serfd < 0) {
	printf("Starting server...");
	system("./ir-server");
	serfd = connect_server();
	if (serfd < 0) {
	    printf ("Can't connect to server!\n");
	    abort();
	}
    }
    printf("Connected to server via %d.\n", serfd);

    fcntl(serfd, F_SETFL, O_NONBLOCK);

    port[0xd8-0x88].set = set_SMR;
    port[0xd8-0x88].get = get_SMR;
    port[0xd9-0x88].set = set_BRR;
    port[0xd9-0x88].get = get_BRR;
    port[0xda-0x88].set = set_SCR;
    port[0xda-0x88].get = get_SCR;
    port[0xdb-0x88].set = set_TDR;
    port[0xdb-0x88].get = get_TDR;
    port[0xdc-0x88].set = set_SSR;
    port[0xdc-0x88].get = get_SSR;
    port[0xdd-0x88].get = get_RDR;

    register_peripheral(serial);
}

int main(int argc, char * argv[])
{
	int sock_fd;
	unsigned long port;
	char * caddr, * endptr;

	if (argc != 4) {
		fprintf(stderr, "Usage: %s address port_number message\n", argv[0]);
		exit(1);
	}

	caddr = argv[1];
	port = strtoul(argv[2], &endptr, 10);

	if (endptr[0] != 0 || port > UINT16_MAX) {
		fprintf(stderr, "Invalid argument %s for port number\n", argv[2]);
		exit(1);
	}

	sock_fd = connect_server(caddr, port);
	send_msg(sock_fd, argv[3]);
	close(sock_fd);

	return 0;
}

static void test_subscribe(void) {
  char buf[512];
  char *msg[] = {
    "SUBSCRIBE\n",
    "destination:/queue/test\n",
    "content-length:0\n",
    "id:test1\n",
    "\n",
    NULL,
  };
  int sock;
  char *headers[] = {
    "destination:/queue/test\n",
  };

  sock = connect_server();

  // success to connect with server
  CU_ASSERT(stomp_connect(sock) == RET_SUCCESS);

  // success to send test message
  CU_ASSERT(stomp_send(sock, "hoge\n", 5, headers, 1) == RET_SUCCESS);

  int i;
  for(i=0; msg[i] != NULL; i++) {
    send(sock, msg[i], strlen(msg[i]), 0);
  }
  send(sock, "\0", 1, 0);

  int len = test_recv(sock, buf, sizeof(buf));
  CU_ASSERT(len > 0);
  CU_ASSERT(strncmp(buf, "MESSAGE\n", 8) == 0);

  close(sock);
}

static int run_test(int server)
{
    int i;

    if( server ){
        connect_server();
    } else {
        connect_client();
    }

    poll_prepare();

    for(i=1; i <= 4194304; i *= 2){
        int rep, j;
        if( i < 4096 ){
            rep = 100;
        } else {
            rep = 10;
        }
        /* warmup */
        for(j=0; j < rep/10; j++){
            progress(server, i);
        }
        double start = GET_TS();
        for(j=0; j < rep; j++){
            progress(server, i);
        }
        double time = GET_TS() - start;
        printf("%d\t%lf\t%lf\n",i, time / rep / 2 * 1000000, 
                (double)progress_count / progress_calls);
        progress_count = 0;
        progress_calls = 0;
    }
}

int
main(int argc, char *argv[])
{
    char *cp, *remote_path, *fname;

    /*
     *  parse args
     */
    if (argc != 4)
        usage();

    hc_host = argv[1];
    cp = strtok(hc_host, ":");
    cp = strtok(NULL, ":");
    if (cp != NULL)
        port = atoi(cp);
    remote_path = argv[2];
    fname = argv[3];

    connect_server();

    /* time(&start_time); */
    get_file(remote_path, fname);

    /*
     *  clean up
     */
    quit(0);
    return 0;  /* for lint */
}

int main()
{
	//clock_t startTime;
	//clock_t endTime;
	//startTime = clock();

	network net = read_network_from_file("exmpl100.in");

	web::json::value js = network_to_jason(net,3,0,99);

	vector<vector<int>> Gdds = connect_server(net, 3, 0, 99);

	//vector<vector<int>> gdd(net.Number_of_Vertices, vector<int>(73, 0));
	//enumerateSubgraphs(net, network_adjacency, 5, gdd, dictionary);
	//enumerateSubgraphs(net, network_adjacency, 4, gdd, dictionary);
	//enumerateSubgraphs(net, network_adjacency, 3, gdd, dictionary);
	//enumerateSubgraphs(net, network_adjacency, 2, gdd, dictionary);
	//endTime = clock();
	//double t = (endTime - startTime) / CLOCKS_PER_SEC;
	//bool check = check_answers(gdd);
	//cout << check << endl << t << endl;

	//free(net.gVector);
	//free(net.dInfo);

	return 0;

}

/* l'ancienne commande...				 */
int reconnect_after_timeout(int refait_commande) {
   int code, ret;
   char *chaine_to_sauve, *ptr;

   aff_try_reconnect();
   close(tcp_fd);
   ptr=strchr(line_write,'\n');
   if (ptr) *(++ptr)='\0';
   chaine_to_sauve=safe_strdup(line_write);
   code=connect_server(Options.serveur_name,0);
   if ((code!=200) && (code!=201)) { free(chaine_to_sauve); return -1; }
   adjust_time();   /* il faut peut-être mieux le refaire, si c'est possible */
   /* reste a envoyer la bonne commande pour GROUP */
   if (refait_commande) {
     ret=(Newsgroup_courant ? va_dans_groupe() : 1);
     if (ret==-1) { free(chaine_to_sauve); return -1; }
     if (ret==0) {
       code=return_code(); 
       if (code<0) { free(chaine_to_sauve); return -1; }
     }
     if (debug) fprintf(stderr, "Reste a renvoyer la commande bugguante\n");
     raw_write_server(chaine_to_sauve, strlen(chaine_to_sauve)); 
      /* on renvoie la commande... */
   }
   if (debug) fprintf(stderr, "Reconnexion réussie ...\n");
   free(chaine_to_sauve);
   aff_end_reconnect();
   return 0;
}

/*
 * shoggoth mounting_point filesystem_name [fuse_options]
 */
int main(int argc, char *argv[]) {
	struct sockaddr_in addr;
	struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
	int i;
	char fs_name[256];

	memset(fs_name, 0, 256);
	for(i = 0; i < argc; i++) {
		   if (i == 1)
				 strncpy(fs_name, argv[i], 256);
		   else
				 fuse_opt_add_arg(&args, argv[i]);
	}

	if (!fs_name[0])
		return 1;

	srand(time(NULL));

	if (find_filesystem(fs_name, &addr) < 0)
		return 1;

	if (!connect_server(addr))
		return 1;

	return fuse_main(args.argc, args.argv, &operations, NULL);
}

int main(int argc, char *argv[])
{
	int val = 0;
	int num = getpid();

	// 连接服务器
	printf("%d号消费者开启。正在连接服务器。。。\n", num);
	int sfd = connect_server(SERVER_IP);
	char msg[BUF_SIZE];
	char type[BUF_SIZE];

	printf("连接成功。开始消费。\n");
	int t = OPCNTS;
	while (t--) {
		sprintf(msg, "%s %d -1\n", CONSUMER, num);
		sndmsg(sfd, msg, strlen(msg));
		rcvmsg(sfd, msg, BUF_SIZE);
		sscanf(msg, "%s%d%d", type, &num, &val);
		printf("%d号消费者进程从共享内存区中取出数据%d成功.\n", num, val);
		usleep(100000);		// 等待100毫秒
	}
	// 消费者消费结束标志
	sprintf(msg, "%s %d -1\n", END, num);
	sndmsg(sfd, msg, strlen(msg));
	printf("%d号消费者结束。\n", num);

	close(sfd);
	return 0;
}

static void test_begin(void) {
  char buf[512];
  char *msg[] = {
    "BEGIN\n",
    "content-length:0\n",
    "transaction:tx1\n",
    "\n",
    NULL,
  };
  int sock, len, i;

  sock = connect_server();
  assert(sock > 0);

  for(i=0; msg[i] != NULL; i++) {
    len = send(sock, msg[i], strlen(msg[i]), 0);
    CU_ASSERT(len > 0);
  }
  send(sock, "\0", 1, 0);

  sleep(0.5);

  /* check not to receive ERROR frame */
  len = recv(sock, buf, sizeof(buf), MSG_DONTWAIT);
  CU_ASSERT(len < 0);

  close(sock);
}

int main(int argc, char **argv)
{
    int sockfd = 0, n = 0, length = 0;
    char recvBuff[BUFFER_SIZE];
    PORT_NUM t = P2C;

    if (argc != 2)
    {
	printf("\nUsage: %s <ip of server>\n", argv[0]);
	exit(0);
    }

    memset(recvBuff, 0x00, sizeof(recvBuff));
    sockfd = init_socket();
    if (sockfd < 0)
	exit(0);
    if (connect_server(t, sockfd, argv[1]) < 0)
	exit(0);

    if ( read_data(sockfd, &length, sizeof(length)) )
	exit(0);
    if ( read_data(sockfd, recvBuff, length) )
	exit(0);

    printf("%s\n", recvBuff);

    exit(0);
}

static void
try_reconnect(void *param)
{
  if(me.uplink == NULL)
  {
    ilog(L_ERROR, "Uplink went away, trying to reconnect");
    connect_server();
  }
}

int main(int argc, char **argv) {
  signal(SIGINT, sighandler);

  int socket_id;
  char *hostname;
  char buffer[256];
  
  if (argc < 2) {
      printf("Usage: client <hostname>\n");
      exit(1);
  } else {
      hostname = argv[1];
  }
    
  socket_id = connect_server(hostname);
  //printf("<client> connect returned: %d\n", socket_id);
  printf("Connected to server: %s\n", hostname);
	
  int type = -1;  // 0 (tutor) or 1 (tutee) - get this from login
  type = (int)argv[2][0] - 48;  // convert from ASCII value
  // send type to server
  write(socket_id, &type, sizeof(type));
  /**
  int subj;
  subj = (int)argv[3][0] - 48;
  */

  while(socket_id >= 0){

    //printf("<client> waiting\n");
    char s[MSG_SIZE];
    sleep(1);
    read(socket_id, s, sizeof(s));
    //printf("<client> received: %s\n", s);
	if (type == TUTEE_ID) 
		printf("Tutor: %s", s);
	else
		printf("Tutee: %s", s);
    printf("You: ");
    fgets(s, sizeof(s), stdin);
	if (strcmp(s, "exit\n") == 0) {
		if (type == TUTEE_ID) {
			printf("Goodbye\n");
			close(socket_id);
			exit(0);
		} else {
			printf("Please wait for the tutee to exit!\n");
			printf("You: ");
		    fgets(s, sizeof(s), stdin);
		}
	}
    write(socket_id, s, sizeof(s));

  }

  return 0;
}

mysql_interface::mysql_interface (const char *h, const char *u, const char *p, unsigned int bind_port)
{
	mysql_init(&handle);
	safe_copy_string (host, h);
	safe_copy_string (user, u);
	safe_copy_string (pass, p);
	port = bind_port;
	this->is_log_debug_sql=0;
	DEBUG_LOG("DB conn msg [%s][%s][%s]",h,u,p);
	connect_server ();
}

static char *perform_http_request (char *host, int port)
{
    char *data;
    int sock;

    sock = connect_server (host, port);
    send_request (sock);
    read_result (sock, &data);
    close_connection (sock);

    return data;
}

jint JNIDEFINE(connectServer)(JNIEnv *env, jobject obj, jstring string)
{
	int len;
	char *cstring;
	cstring = jstring2cstring(env, string);
	len = strlen(cstring);
	if(len >= 7 && len <=15)
		connect_server(cstring);
	else
		LOGD("ip address error!\n");
	return 0;
}

/* StartMQ for windows */
int StartMQ(char * path, short int type)
{
    /* Connecting to the server. */
    connect_server(0);

    if((path == NULL) && (type == 0))
    {
        return(0);
    }

    return(0);
}

int main(int argc, char *argv[])
{
    int client_flag, server_cmd;

    if (!connect_server())
    {
        qDebug() << "Not connected control server!";
        return 1;
    }
    else
    {
        qDebug() << "Connected to control server!";
    }
    if (!connect_psdb())
    {
        qDebug() << "Not connected parameter server database!";
        return 1;
    }
    else
    {
        qDebug() << "Connected to parameter server database!";
    }
    while (1)
    {
        server_cmd = request_cmd();
        switch (server_cmd)
        {
            case cmd_work:

                client_flag = execute_evo_motor();
                break;
            case cmd_term:
                qDebug() << "cmd_exit";
                break;
            default:
                qDebug() << "error exit";
                break;
        }
        switch (client_flag)
        {
            case flag_success:
                send_signal(flag_success);
                break;
            case flag_failure:
            default:
                qDebug() << "flag_failure";
                send_signal(flag_failure);
                break;
        }
    }
    return 0;
}

/** Called when resolver query finishes.  If the DNS lookup was
 * successful, start the connection; otherwise notify opers of the
 * failure.
 * @param[in] vptr The struct ConfItem representing the Connect block.
 * @param[in] addr The resolved IP address (NULL on failure).
 * @param[in] h_name The name being looked up.
 */
static void connect_dns_callback(void* vptr, const struct irc_in_addr *addr, const char *h_name)
{
  struct ConfItem* aconf = (struct ConfItem*) vptr;
  assert(aconf);
  aconf->dns_pending = 0;
  if (addr) {
    memcpy(&aconf->address, addr, sizeof(aconf->address));
    connect_server(aconf, 0);
  }
  else
    sendto_opmask(0, SNO_OLDSNO, "Connect to %s failed: host lookup",
                  aconf->name);
}

//初始化播放器界面所需要的全局变量，并启动播放状态刷新、歌词刷新线程
int init_music() {
	//设置配置路径
// 	config_music_file_path = strdup("./config/config_music.txt");
	
	//分析并设置配置变量
	
	if ((client_sock = connect_server(cur_config_music.music_server_ip, cur_config_music.socket_port)) < 0) {
		printf("error: connect_server failed\n");
	}
	client_music_info.play_path = -1;
// 	get_music_dirs_from_server();
	g_thread_new(NULL, data_update_client_music_info_for_thread, NULL);
}