示例#1
0
文件: test-poll.c 项目: 0-wiz-0/libuv
static void start_poll_test(void) {
  int i, r;

#ifdef _WIN32
  {
    struct WSAData wsa_data;
    int r = WSAStartup(MAKEWORD(2, 2), &wsa_data);
    ASSERT(r == 0);
  }
#endif

  start_server();

  for (i = 0; i < NUM_CLIENTS; i++)
    start_client();

  r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
  ASSERT(r == 0);

  /* Assert that at most five percent of the writable wakeups was spurious. */
  ASSERT(spurious_writable_wakeups == 0 ||
         (valid_writable_wakeups + spurious_writable_wakeups) /
         spurious_writable_wakeups > 20);

  ASSERT(closed_connections == NUM_CLIENTS * 2);
  ASSERT(disconnects == NUM_CLIENTS * 2);

  MAKE_VALGRIND_HAPPY();
}
示例#2
0
int main(int argc, char **argv) {
    int c;
    int option_index = 0;
    int count = -1;
    int server = 0;
    static struct option long_options[] = {
        {"count", required_argument, 0, 'c'},
        {"server", no_argument, 0, 's'},
        {0, 0, 0, 0 }
    };
    while (1) {
        c = getopt_long(argc, argv, "c:s", long_options, &option_index);
        if (c == -1)
            break;
        switch (c) {
        case 'c':
            count = atoi(optarg);
            break;
        case 's':
            server = 1;
            break;
        }
    }
    if (server) start_server();
    else start_client(count);
    return 0;
}
示例#3
0
	//Function that reset the network when the scene
	//is restarted
	void Network::reset() {
		if (has_server && server)
			start_server();
		if (has_client && client)
			start_client();
		NetId::last_id = 0;

	}
示例#4
0
文件: client.c 项目: phrasz/CookBook
int main (int argc,char **argv){
   struct sockaddr_in server;
   struct fgetinfo    *p1;
   struct finfo       p4;
   char               buffer[10000];
   FILE *foutfd;
   
   char host[1000],fin[FILENAME_MAX],fout[FILENAME_MAX];
   int sock,port,connected,retval;
 
   parse(argc,argv,host,&port,fin,fout);
   
   /* PRINT PARSED ARGUMENTS */
   printf("Port %i<--\n",port);
   printf("Server %s<--\n",host);

   start_client(&sock,&server,port,host);
   printf("Starting communication\n\n");
   p1=get_info(fin);

   // Try to open out file
   if((foutfd=(FILE *)fopen(fout,"wb"))==NULL){
      printf("Out file could't be created or truncated for writing\n");
      exit(1);
   }
   
   connected=0;
   while (connected<3){
      connected++;
      send_buf(sock,&server,p1,sizeof(*p1));
      print_fgetinfo(*p1);
      
      if(receive(sock,buffer,sizeof(buffer))==0){
         memcpy(&p4,buffer,sizeof(p4));
         if(!check_finfo(p4)){
            connected=4;
            print_finfo(p4);
            if (p4.file_exist==1){
               // Start transfer
               retval=transfer(sock,&server,p4.file_id,foutfd,p4.file_size);
               fclose(foutfd);
               // Show transfer result
               exit(retval);
            }
            else{
               printf("\nERROR: Requested file does not exist on server\n\n");
               exit(1);
            }
         }
      }
   }
   if (connected==3){
      printf("\nERROR: Server not responding\n\n");
      exit(1);
   }
   exit (0);
}
示例#5
0
/**
 *  \brief USB manager's client side interfacing. Functions in this 
 *         file acts as glue to the client side call. 
 */
int connect_to_usb_manager(void *args)
{
    printf("\n\n\n\n Thread entry -- %s", __func__);
    struct chips_context *context = chips_get_context();
    context->init();
    printf("\n USB_DRIVER: Context init at usb_manager client"
           "Trying to connect\n ");
    start_client(context);
    return 0;
}
示例#6
0
int
main(int argc, char * const argv[]) {
  if (argc != 3) {
    fprintf(stderr, "Usage: \n");
    fprintf(stderr, "  %s ciphersuite certificate\n", argv[0]);
    fprintf(stderr, "\n");
    fprintf(stderr, " - `ciphersuite` is the name of cipher suite to use. Use\n");
    fprintf(stderr, "   `openssl ciphers` to choose one.\n");
    fprintf(stderr, "\n");
    fprintf(stderr, " - `certificate` is the name of the file containing\n");
    fprintf(stderr, "   the certificate, the key and appropriate additional parameters.\n");
    return 1;
  }

  const char *ciphersuite = argv[1];
  const char *certificate = argv[2];

  start("Initialize OpenSSL library");
  SSL_load_error_strings();
  SSL_library_init();
  if (!(mutex_buf = malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t))))
    fail("Unable to allocate memory for mutex");
  for (int i = 0;  i < CRYPTO_num_locks();  i++)
    pthread_mutex_init(&mutex_buf[i], NULL);
  CRYPTO_set_id_callback(id_function);
  CRYPTO_set_locking_callback(locking_function);

  pthread_t client, server;
  start("Prepare client and server");
  if (socketpair(AF_UNIX, SOCK_STREAM, 0, clientserver))
    fail("Unable to get a socket pair for client/server communication:\n%m");
  server = start_server(ciphersuite, certificate);
  client = start_client(ciphersuite);

  struct result *client_result, *server_result;
  start("Waiting for client to finish");
  if (pthread_join(client, (void **)&client_result))
    fail("Unable to join client thread");
  start("Waiting for server to finish");
  if (pthread_join(server, (void **)&server_result))
    fail("Unable to join server thread");

  end("Got the following results:\n"
      "Handshakes from client: %d\n"
      "User CPU time in client: %4ld.%03ld\n"
      "Handshakes from server: %d\n"
      "User CPU time in server: %4ld.%03ld\n"
      "Ratio: %.2f %%",
      client_result->handshakes,
      client_result->cpu.tv_sec, client_result->cpu.tv_nsec / 1000000,
      server_result->handshakes,
      server_result->cpu.tv_sec, server_result->cpu.tv_nsec / 1000000,
      (server_result->cpu.tv_sec * 1000. + server_result->cpu.tv_nsec / 1000000.) * 100. /
      (client_result->cpu.tv_sec * 1000. + client_result->cpu.tv_nsec / 1000000.));
}
int
main(int argc, char **argv) {
	in_addr_t local_addr;
	uint16_t port;
	uint16_t istreams, ostreams;
	uint16_t max_attemps, max_timeout;
	int c;

	local_addr = INADDR_ANY;
	port = 0;
	istreams = 0;
	ostreams = 0;
	max_attemps = 0;
	max_timeout = 0;

	while ((c = getopt(argc, argv, "hL:i:o:N:p:T:")) != -1) {
		switch(c) {
			case 'h':
				fprintf(stderr, "%s", Usage);
				return 0;
				break;
			case 'i':
				istreams = atoi(optarg);
				break;
			case 'L':
				local_addr = inet_addr(optarg);
				break;
			case 'N':
				max_attemps = atoi(optarg);
				break;
			case 'o':
				ostreams = atoi(optarg);
				break;
			case 'p':
				port = atoi(optarg);
				break;
			case 'T':
				max_timeout = atoi(optarg) * 1000;
				break;
			default:
				fprintf(stderr, "%s", Usage);
				return -1;
		}
	}

	if (optind == argc) {
		start_server(local_addr, istreams, ostreams);
	} else {
		start_client(local_addr, port, inet_addr(argv[optind]), atoi(argv[optind+1]),
		             istreams, ostreams, max_attemps, max_timeout);
	}

	return 0;
}
示例#8
0
int start(int argc, char *argv[]) {
	
	printf(".:: TCP PING ::.\n");
	if(!processArguments(argc, argv)) return -1;
	
	if(mode == SERVER) {
		start_server(CONFIG_LISENT_IFACE, port, CONFIG_MAX_CLIENT);
	} else if(mode == CLIENT) {
		start_client(ip_dst,port,msg_count,msg_size);
	}
	
	return 0;
}
示例#9
0
/// seriously? you are reading what main is about? go away!
int main(int argc, char *argv[]) {
    char const* dev;

    sender_address = 1;
    destination_address = 254;

    if (argc < 2) {
        LOG_WARN("Running in stdin/stdout mode. Expecting two different FIFOs (or pipes) to read/write.");
        LOG_INFO("You may run for example:");
        LOG_INFO("mkfifo \"$MYFIFO\" && ./client < \"$MYFIFO\" | ./gateway - eth0 > \"$MYFIFO\"; [ -p \"$MYFIFO\" ] && rm \"$MYFIFO\"");
        dev = 0; //special meaning
    } else {
        dev = argv[1];
    }

    start_client(dev);
    return 0;
}
示例#10
0
int main(int argc, char *argv[], char *envp[]) {
    /* avoid SIGPIPE */
    signal(SIGPIPE,SIG_IGN);
    
    /* avoid erroneous signal from other mbbsd */
    signal(SIGUSR1,SIG_IGN);
    signal(SIGUSR2,SIG_IGN);
    
    /* check if invoked as "bbs" */
    if(argc == 3)
	shell_login(argc,argv,envp);
    else
    	daemon_login(argc,argv,envp);
    
    nice(2);	/*  Ptt: lower priority */
    login_start_time = time(0);
    start_client();
    return 0;
}
示例#11
0
文件: main.cpp 项目: tmhm/Qt4_Desktop
/* 主函数 */
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    int i;
    int r;
    int port = 8888;
    bool server_mode =1;
    char *addr =NULL;
    port = DEFAULT_PORT;
    server_mode = 0;
    addr = "172.20.9.59";
    /* 对命令行参数进行分析 */
    for (i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-s") == 0) { /* 如果是 -s */
            server_mode = 1; /* 说明要以服务器方式启动 */
        } else if (strcmp(argv[i], "-p") == 0) { /* 如果是 -p */
            server_mode = 0;  /* 说明要以client方式启动 */
            i++; /* 下一个参数 */
            if (i >= argc) {
                printf("Error: must specify port number!\n");
                return -1;
            }
            port = atoi(argv[i]); /* 是端口号 */
            if (port == 0) {
                printf("Error: wrong port number!\n");
                return -1;
            }
        } else { /* 否则 */
            addr = argv[i]; /* 是 IP 地址 */
        }
    }
    if (server_mode) {
        r = start_server(port); /* 启动服务器 */
    } else {
        r = start_client(addr, port); /* 启动客户端 */
    }
//    return r;


    
    return a.exec();
}
示例#12
0
/* Check that the server sends back the same byte that the client sent.
   If MAX_REQUESTS have been reached, exit. Otherwise, start another client. */
static void
client_read_cb(struct bufferevent *bev, void *ctx)
{
	unsigned char tmp;
	struct event_base *base = bufferevent_get_base(bev);

	bufferevent_read(bev, &tmp, 1);
	if (tmp != 'A') {
		puts("Incorrect data received!");
		exit(2);
	}
	bufferevent_free(bev);

	num_requests++;
	if (num_requests == MAX_REQUESTS) {
		event_base_loopbreak(base);
	} else {
		start_client(base);
	}
}
示例#13
0
/* Start the server listening on a random port and start the first client. */
static void
start_loop(void)
{
	struct event_base *base;
	struct evconnlistener *listener;
	struct sockaddr_storage ss;
	ev_socklen_t socklen = sizeof(ss);
	evutil_socket_t fd;

	base = event_base_new();
	if (base == NULL) {
		puts("Could not open event base!");
		exit(1);
	}

	listener = evconnlistener_new_bind(base, listener_accept_cb, NULL,
	    LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE,
	    -1, (struct sockaddr *)&saddr, sizeof(saddr));
	if (listener == NULL) {
		my_perror("Could not create listener!");
		exit(1);
	}
	fd = evconnlistener_get_fd(listener);
	if (fd < 0) {
		puts("Couldn't get fd from listener");
		exit(1);
	}
	if (getsockname(fd, (struct sockaddr *)&ss, &socklen) < 0) {
		my_perror("getsockname()");
		exit(1);
	}
	memcpy(&saddr, &ss, sizeof(saddr));
	if (saddr.sin_family != AF_INET) {
		puts("AF mismatch from getsockname().");
		exit(1);
	}

	start_client(base);

	event_base_dispatch(base);
}
示例#14
0
文件: main.cpp 项目: Sedecimi/chRtik
int parse_args(int argc, char* argv[]) {
    if(argc < 2) {
        fprintf(stderr,"Take an arguments or use --help\n");
        return argc;
    }
    bool hs=true;
    for(int i = 1; i < argc; i++) {
        if(argv[i][0]=='-') {
            if((!strcmp(argv[i], "--help")||!strcmp(argv[i],"-h"))&&hs) {
                show_help();
                hs=!hs;
            }
            if(!strcmp(argv[i], "-s")) {
                fprintf(stdout, "Start as server\n");
                start_server(argv[i++]);
            }
            if(!strcmp(argv[i], "--server-cfg")) {
                fprintf(stdout, "Let's configure a server!\n");
                server_cfg(argv[i++]);
            }
            if(!strcmp(argv[i], "-c")) {
                fprintf(stdout, "Start as client\n");
                start_client(argv[i++]);
            }
            if(!strcmp(argv[i], "-r")) {
                fprintf(stdout, "Start a registration\n");
                registration(argv[i++]);
            }
        }
        else {
            fprintf(stderr, "Wrong arguments\n");
            if(hs)
                show_help();
            return 0;
        }
    }
    return 0;
}
示例#15
0
int main(int argc, char *argv[])
{
	if (signal(SIGINT, sig_handler) == SIG_ERR)
	  printf("\ncan't catch SIGINT\n");
	// check command line args.

//		if (argc == 2)
//		{
//			// then run in routing table mode
//			buildrt(argv[1]);
//			exit(0);
//		}

	if (argc == 2)
	{
		// then running in server mode
		printf("Running in server mode with port %s\n", argv[1]);
		strcpy(port, argv[1]);
		start_server(port);
	}
	else if (argc < 4)
	{
		printf("usage : %s <client name> <server IP> <server port> \n", argv[0]);
		exit(1);
	}

	if (argc == 4)
	{
		printf("Running as client:\n");
		strcpy(clientName, argv[1]);
		strcpy(serverIp, argv[2]);
		strcpy(serverPort, argv[3]);
		start_client(clientName, serverIp, serverPort);
	}
	return 0;


}
示例#16
0
int main(int argc, char *argv[])
{
    errval_t err;

    if ((argc >= 2) && (strcmp(argv[1], "client") == 0)) {
        start_client();
    } else if ((argc >= 2) && (strcmp(argv[1], "server") == 0)) {
        start_server();
    } else {
        printf("usage: %s client|server\n", argv[0]);
        return EXIT_FAILURE;
    }

    struct waitset *ws = get_default_waitset();
    while (1) {
        err = event_dispatch(ws);
        if (err_is_fail(err)) {
            DEBUG_ERR(err, "in event_dispatch");
            break;
        }
    }

    return EXIT_FAILURE;
}
示例#17
0
/* 主模块 */
int main(int argc, char *argv[])
{
	int i;
	int r;
	int port;
	int server_mode;
	char *addr;
	port = DEFAULT_PORT;
	server_mode = 0;
	addr = "202.206.219.143";
	/* 对命令行参数进行分析 */
	for (i = 1; i < argc; i++) {
		if (strcmp(argv[i], "-s") == 0) { /* 如果是 -s */
			server_mode = 1; /* 说明要以服务器方式启动 */
		} else if (strcmp(argv[i], "-p") == 0) { /* 如果是 -p */
			i++; /* 下一个参数 */
			if (i >= argc) {
				printf("Error: must specify port number!\n");
				return -1;
			}
			port = atoi(argv[i]); /* 是端口号 */
			if (port == 0) {
				printf("Error: wrong port number!\n");
				return -1;
			}
		} else { /* 否则 */
			addr = argv[i]; /* 是 IP 地址 */
		}
	}
	if (server_mode) {
		r = start_server(port); /* 启动服务器 */
	} else {
		r = start_client(addr, port); /* 启动客户端 */
	}
	return r;
}
示例#18
0
////////////////////////////////////////////////////////////////////////////////
// Main
int main()
{
	start_server();
	start_client();
	return 0;
}
示例#19
0
文件: fwannoyer.c 项目: aquini/misc
void start_client(char *srv, int port)
{
    int socket_d, ret;
    socklen_t len_inet;
    struct sigaction sa;
    struct sockaddr_in in_addr;
    char buf[bufsize];
    ssize_t reads;
    struct timespec rem;
    struct timespec req = { .tv_sec = 0,
               .tv_nsec = 1492000
    };

    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    sa.sa_handler = chld_reaper;
    if (sigaction(SIGCHLD, &sa, NULL) == -1)
        oops("error from sigaction()");

    socket_d = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_d == -1)
        oops("error from socket()");

    len_inet = sizeof(struct sockaddr_in);

    memset(&in_addr, 0, len_inet);
    in_addr.sin_family = AF_INET;
    in_addr.sin_port = htons(port);
    in_addr.sin_addr.s_addr = inet_addr(srv);

    if (connect(socket_d, (struct sockaddr *)&in_addr, len_inet) == -1)
        oops("error from connect()");

    switch(fork()) {
    case -1:
        oops("error from fork()");

    case 0:  /* child -- read server's response */
        for (;;) {
            reads = readn(socket_d, buf, bufsize);
            if (reads <= 0)
                break;

            printf("%.*s", (int) reads, buf);
        }
        exit(EXIT_SUCCESS);

    default: /* parent -- write stdin to socket */
        for (;;) {
            req.tv_nsec++;
            if (req.tv_nsec >= 14920000)
                req.tv_nsec = 1492000;

            reads = read(STDIN_FILENO, buf, bufsize);
            if (reads <= 0)
                break;

            /* insert some sleep */
retry:
            ret = nanosleep(&req, &rem);
            if (ret) {
                if (errno == EINTR) {
                    req.tv_sec = rem.tv_sec;
                    req.tv_nsec = rem.tv_nsec;
                    goto retry;
                }
                syslog(LOG_ERR, "nanosleep() failed: %s",
                       strerror(errno));
            }

            writen(socket_d, buf, bufsize);

        }
        exit(EXIT_SUCCESS);
    }
}

int main(int argc, char *argv[])
{
    int next_opt, mode = 0;
    char *server = NULL;
    const char *short_opts = "hsc:p:b:";
    const struct option long_opts[] = {
        {"help", 0, NULL, 'h'},
        {"server", 0, NULL, 's'},
        {"client", 1, NULL, 'c'},
        {"port", 1, NULL, 'p'},
        {"bufsz", 1, NULL, 'b'},
        {NULL, 0, NULL, 0}
    } ;

    int port_num = 9999;
    prg_name = argv[0];

    do {
        next_opt = getopt_long(argc, argv, short_opts, long_opts, NULL);
        switch (next_opt) {
        case 'h':
            print_usage(stdout, 0);

        case 's':
            mode += 1;
            break;

        case 'c':
            mode += 2;
            server = optarg;
            break;

        case 'p':
            port_num = atoi(optarg);
            break;

        case 'b':
            bufsize = atoi(optarg);
            break;

        case '?':
            print_usage(stderr, 1);

        case -1:
            break;

        default:
            abort();
        }
    } while (next_opt != -1);

    if (argc == 1)
        print_usage(stderr, 2);

    if (mode == 0 || mode > 2)
        oops("Ok, I cannot realize what you want now...");

    switch (mode) {
    case 1: /* server mode */
        if (deamonize() == -1)
            oops("failed to become a deamon.");

        start_server(port_num);
        break;
    case 2: /* client mode */
        start_client(server, port_num);
        break;
    }

    return 0;
}
示例#20
0
int main(int argc , char *argv[]) {
  /* Get program name. */
  char *progname = strrchr(argv[0], '/');
  if (progname)
    progname++;
  else
    progname = argv[0];

  /* Possible command-line arguments. */
  bool is_server = 0;
  bool is_client = 0;
  char *server = NULL;
  char *port_str = NULL;
  int port = -1;
  int window = 1;
  seed = time(NULL);
  test_debug_on = false;
  lab5_mode = false;
  struct option o[] = {
    { "debug", no_argument, NULL, 'd' },

    { "server", no_argument, NULL, 's' },
    { "client", required_argument, NULL, 'c' },
    { "port", required_argument, NULL, 'p' },
    { "window", required_argument, NULL, 'w' },

    { "seed", required_argument, NULL, 'e'},
    { "drop", required_argument, NULL, 'r' },
    { "corrupt", required_argument, NULL, 't' },
    { "delay", required_argument, NULL, 'y' },
    { "duplicate", required_argument, NULL, 'q' },
    { "logging", no_argument, NULL, 'l' },
    { "lab5", no_argument, NULL, 'f' },
    { NULL, 0, NULL, 0 }
  };

  /* Parse command-line arguments. */
  int opt;
  while ((opt = getopt_long(argc, argv, "dsc:p:w:r:t:y:q:lzf", o, NULL)) != -1) {
    switch (opt) {
    /* Debug statements on. */
    case 'd':
      DEBUG = true;
      break;
    /* Run as server. */
    case 's':
      is_server = true;
      break;
    /* Run as client and connect to a specified server. */
    case 'c':
      is_client = true;
      server = optarg;
      break;
    /* Port to run on. */
    case 'p':
      port = atoi(optarg);
      port_str = optarg;
      break;
    /* Window size. */
    case 'w':
      window = atoi(optarg);
      break;
    /* Seed for unreliability. */
    case 'e':
      seed = atoi(optarg);
      break;
    /* Segment drop. */
    case 'r':
      opt_drop = atoi(optarg);
      break;
    /* Segment corruption. */
    case 't':
      opt_corrupt = atoi(optarg);
      break;
    /* Segment delay. */
    case 'y':
      opt_delay = atoi(optarg);
      break;
    /* Segment duplicate. */
    case 'q':
      opt_duplicate = atoi(optarg);
      break;
    /* Turn logging on. */
    case 'l':
      log_file = 0;
      break;
    /* Turn logging data off for tester. */
    case 'z':
      test_debug_on = true;
      break;
    /* Lab 5 mode for handling FINs. */
    case 'f':
      lab5_mode = true;
      break;
    default:
      usage(progname);
      break;
    }
  }

  /* Seed RNG. */
  srand(seed);

  /* Validate arguments. */
  if ((is_client && is_server) || (!is_client && !is_server) || port <= 0) {
    usage(progname);
  }

  /* Construct log file if logging is turned on. Don't create a file if not
     logging data, since that is only used for testing purposes. */
  if (log_file == 0) {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    char log_filename[40];
    memset(log_filename, 0, 40);
    snprintf(log_filename, sizeof(log_filename), "%d-%d.csv", (int) tv.tv_sec,
             port);
    log_file = open(log_filename, O_CREAT | O_TRUNC | O_WRONLY, 0666);
    write_log_header(log_file);
  }

  /* Global configuration. */
  struct config cc;
  config = &cc;

  /* CTCP config for students. */
  static ctcp_config_t cfg;
  ctcp_cfg = &cfg;
  cfg.recv_window = window * MAX_SEG_DATA_SIZE;
  cfg.send_window = window * MAX_SEG_DATA_SIZE;
  cfg.timer = TIMER_INTERVAL;
  cfg.rt_timeout = RT_INTERVAL;

  /* Used for polling later. */
  struct pollfd _events[NUM_POLL + MAX_NUM_CLIENTS];
  memset(_events, 0, sizeof(struct pollfd) * (NUM_POLL + MAX_NUM_CLIENTS));
  events = _events;

  /* Start client/server. */
  if (is_client) {
    if (start_client(server, port_str) < 0) {
      fprintf(stderr, "[ERROR] Client terminated\n");
      return 1;
    }
  }
  else if (is_server) {
    SERVER = true;
    if (start_server(port_str, argc, argv) < 0) {
      fprintf(stderr, "[ERROR] Server terminated\n");
      return 1;
    }
  }
  return 0;
}
示例#21
0
static void APP_main()
{
   ip_connected = false;
   kaa_started = false;

   kaa_error_t kaa_error = KAA_ERR_NONE;
   { //Used to limit kaa_props visibility, it creates on stack and release once is used
       kaa_client_props_t kaa_props;
       kaa_props.max_update_time = 2;
       kaa_error = kaa_client_create(&kaa_client, &kaa_props);
       if (kaa_error) {
           sndc_printf("Error %d initializing Kaa client \n",kaa_error);
           return;
       }
   }

   kaa_list_t *zones = kaa_list_create();
   int i = 0;
   for(; i < LIGHT_ZONES_COUNT; ++i) {
       sndc_io_setMode(light_zones[i], IO_MODE_OUTPUT);
       sndc_io_write(light_zones[i], LIGHT_OFF);
       int32_t *zone_id = (int32_t *) KAA_MALLOC(sizeof(int32_t));
       *zone_id = i;
       kaa_list_push_front(zones, zone_id);
   }
   kaa_profile_street_lights_profile_t *profile = kaa_profile_street_lights_profile_create();
   profile->light_zones = zones;
   kaa_profile_manager_update_profile(kaa_client_get_context(kaa_client)->profile_manager, profile);
   profile->destroy(profile);

   /**
    * Configuration example, below is how to configure and read default configuration values
    */
   kaa_configuration_root_receiver_t receiver = { NULL, &kaa_on_configuration_updated };
   kaa_error = kaa_configuration_manager_set_root_receiver(kaa_client_get_context(kaa_client)->configuration_manager, &receiver);
   sndc_printf("Configuration setting done. %d\n", kaa_error);
   //sndc_thrd_delay(TRACE_DELAY * SNDC_MILLISECOND);
   const kaa_root_configuration_t *root_config = kaa_configuration_manager_get_configuration(kaa_client_get_context(kaa_client)->configuration_manager);
   kaa_on_configuration_updated(NULL, root_config);

   //set SW2 button as key input
   //sndc_io_ctrl(BUTTON,
   //             IO_PIN_FUNC_PULL_UP,
   //             IO_PIN_DRIVE_DEFAULT,
   //             IO_PIN_SLEW_RATE_DEFAULT);
   //sndc_io_setMode(BUTTON, IO_MODE_KEY);

   //sndc_device_config = sndc_config_get();

   /* clean all profiles */
   //sndc_profile_eraseAll();
   //sndc_printf("Press SW2 to start test. \n");

   start_client();

   //infinite thread loop, button press is monitored by system events
   while(1)
   {

      if (ip_connected && !kaa_started) {
          kaa_client_start(kaa_client, NULL, NULL, 0);
          kaa_started = true;
      }
      //thread sleep for 500 ms
      sndc_thrd_delay(500 * SNDC_MILLISECOND);
   }
}
int main(int argc, char *argv[]) {	
	printf(".--FILE TRANSFER CLIENT --.\n");
	if(!processArguments(argc, argv)) return -1;
	start_client(port,ip,remoteFilename,localFilename);
}
示例#23
0
static bool_t APP_handle_msg(sndc_appmsg_msg_t* msg)
{
   bool_t consumed = FALSE;
   switch(msg->id)
   {
      case SNDC_APPMSG_SCAN_COMPLETED:
      {
         sndc_printf("SNDC_APPMSG_SCAN_COMPLETED\n");
         break;
      }
      case SNDC_APPMSG_SCAN_IND:
      {
         sndc_printf("SNDC_APPMSG_SCAN_IND\n");
         break;
      }
      case SNDC_APPMSG_P2P_EVENT:
      {
         sndc_printf("SNDC_APPMSG_P2P_EVENT\n");
         break;
      }
      case SNDC_APPMSG_CM_EVENT:
      {
        sndc_printf("SNDC_APPMSG_CM_EVENT\n");
        sndc_appmsg_cmEvent_t *cm_event = (sndc_appmsg_cmEvent_t *)msg->par;

        sndc_printf("GOT SNDC_APPMSG_CM_EVENT FROM PROFILE ID: %d WITH ID: %d \n", cm_event->priv.profileID, cm_event->id);
        switch(cm_event->id)
        {
         case EVENT_TYPE_CM_PEER_STATUS:
         {
            switch(cm_event->priv.u.peer_status){
               case SNDC_CM_WLAN_DISCONNECTED: sndc_printf( "SNDC_CM_WLAN_DISCONNECTED\n"); break;
               case SNDC_CM_WLAN_CONNECT_TIMEOUT: sndc_printf( "SNDC_CM_WLAN_CONNECT_TIMEOUT\n"); break;
               case SNDC_CM_WLAN_CONNECT_FAILED: sndc_printf( "SNDC_CM_WLAN_CONNECT_FAILED\n"); break;
               case SNDC_CM_WLAN_WPS_FAILED: sndc_printf( "SNDC_CM_WLAN_WPS_FAILED\n"); break;
               case SNDC_CM_WLAN_WPS_TIMEOUT: sndc_printf( "SNDC_CM_WLAN_WPS_TIMEOUT\n"); break;
               case SNDC_CM_WLAN_CONNECTED: sndc_printf( "SNDC_CM_WLAN_CONNECTED\n"); break;
               default: sndc_printf( "[%d] peer_status:%d  \n",cm_event->priv.profileID, cm_event->priv.u.peer_status); break;
            }
            break;
         }
         case EVENT_TYPE_CM_CLIENT_STATUS:
            break;
         case EVENT_TYPE_CM_GO_STATUS:
            break;
         case EVENT_TYPE_CM_IP_ACQUIRED:
         {
            sndc_profile_ipConfig_t *ipconfig = cm_event->priv.u.ip_acquired.ipconfig;
            sndc_printf("**********************\n");
            sndc_printf("IP acquired, status = %d\n", cm_event->priv.u.ip_acquired.status);
            if(cm_event->priv.u.ip_acquired.status == 0)
            {
               assert(ipconfig);
               sndc_printf("IP addr: %s\n", sndc_inet_ntoa(ipconfig->ip_address));
               sndc_printf("Netmask: %s\n", sndc_inet_ntoa(ipconfig->netmask));
               sndc_printf("Gateway: %s\n", sndc_inet_ntoa(ipconfig->gateway));
               ip_connected = true;
               sndc_sys_initRandom(sndc_sys_getTimestamp_msec());
            }
            sndc_printf("**********************\n");


            break;
         }
         case EVENT_TYPE_CM_AUTO_MODE_STATE_CHANGED:
         {
            sndc_printf( "[%d] AutoMode state changed:%d  \n",cm_event->priv.profileID, cm_event->priv.u.auto_mode_state);
            break;
         }

        }

        break;
      }
      case SNDC_APPMSG_IO_EVENT:
      {
         sndc_printf("SNDC_APPMSG_IO_EVENT\n");
         sndc_appmsg_ioEvent_t *io_event = (sndc_appmsg_ioEvent_t *)msg->par;
         if (testDone) {
             sndc_printf("SNDC_APPMSG_IO_EVENT level %d, pinMask %d\n", io_event->level, io_event->pin_mask);
         } else {
             testDone  = true;
             sndc_printf("Button pressed. \n");
             start_client();
         }
         break;
      }

      default:
         break;
   }

   return consumed;
}
示例#24
0
int main(int argc, char *argv[])
{
    int bcSock, udpSocket;                        
    struct sockaddr_in broadcastAddr; 
    char *broadcastIP, strbuffer[255], buffer[255];                
    unsigned short broadcastPort;     
    pid_t forkID; //es un int                 
    
    int broadcastPermission;          
    unsigned int sendStringLen; 

	int status;
	int i;
	int found=0,size = 0;
	struct sockaddr_in udpClient,udpServer;
	socklen_t addrlen = sizeof(udpClient);
	char ip[17], *knownHosts[20];
	static char chosenip[17];
	static char filename[255];
	static char localFilename[255];
	//u_short clientPort;

///El siguiente código lo utilizo para obtener la ip de mi propia PC en la interfaz especificada
struct ifaddrs *ifaddr, *ifa;
    int s;
    char host[NI_MAXHOST];

    if (getifaddrs(&ifaddr) == -1) 
    {
        perror("getifaddrs");
        exit(EXIT_FAILURE);
    }

for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) 
    {
        if (ifa->ifa_addr == NULL)
            continue;  

        s=getnameinfo(ifa->ifa_addr,sizeof(struct sockaddr_in),host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
	//Para interfaz cableada eth0 y wireless wlan0, para loopback cambiar a lo
        if((strcmp(ifa->ifa_name,"eth0")==0)&&(ifa->ifa_addr->sa_family==AF_INET))
        {
            if (s != 0)
            {
                printf("getnameinfo() failed: %s\n", gai_strerror(s));
                exit(EXIT_FAILURE);
            }
            printf("\tInterface : <%s>\n",ifa->ifa_name );
            printf("\t  Address : <%s>\n", host); 
        }
    }
	freeifaddrs(ifaddr);

/////////////fin de código para encontrar mi propia dirección IP.

    if (argc < 3)                     
    {
        //fprintf(stderr,"Usage:  %s <IP Address> <Port> <Send String>\n", argv[0]);
	fprintf(stderr,"Usage:  %s <IP Address> <Port>\n", argv[0]);
        exit(1);
    }

    broadcastIP = argv[1];            /* First arg:  broadcast IP address */ 
    broadcastPort = atoi(argv[2]);    /* Second arg:  broadcast port */
    sprintf(strbuffer,"WHO IS THERE %i\r\n\r\n",(int)broadcastPort);	
	//Creamos bcSock, el socket para enviar	broadcast
	bcSock = socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP);
	if(bcSock == -1) {
		fprintf(stderr,"Can't create Socket");
		return 1;
	}
  	
	//Creamos el udpSocket para recibir mensajes
	udpSocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if(udpSocket == -1) {
		fprintf(stderr,"Can't create UDP Socket");
		return 1;
	}

    broadcastPermission = 1;
    status = setsockopt(bcSock, SOL_SOCKET, SO_BROADCAST, (void *) &broadcastPermission, sizeof(broadcastPermission));
    if(status == -1) {
		fprintf(stderr,"Can't set Brodcast Option");
		return 1;
    }

    memset(&broadcastAddr, 0, sizeof(broadcastAddr));   
    broadcastAddr.sin_family = AF_INET;                 
	inet_pton(AF_INET,broadcastIP,&broadcastAddr.sin_addr.s_addr); 
    broadcastAddr.sin_port = htons(broadcastPort);         
	 sendStringLen = strlen(strbuffer);  

    udpServer.sin_family = AF_INET;
    inet_pton(AF_INET,"0.0.0.0",&udpServer.sin_addr.s_addr);
    udpServer.sin_port = htons(5000);
	//con bind asociamos el socket para recibir (udpSocket) a la dirección del udpServer)
    status = bind(udpSocket, (struct sockaddr*)&udpServer,sizeof(udpServer));
	if(status != 0) { 
	  fprintf(stderr,"Can't bind");
    }	
	forkID = fork(); //////////////START FORK
	////Checar donde poner los exit() y donde cerrar los sockets UDP....
	if(forkID == -1) {
			fprintf(stderr,"Cant Fork\n");
		} else if(forkID == 0) {
			//Soy el HIJO
			//printf("Recibimos: OK\n");
		while(1) {
		bzero(buffer,255);
		status = recvfrom(udpSocket, buffer, 255, 0, (struct sockaddr*)&udpClient, &addrlen );
		////ver por donde se recibe los mensajes del sender para en el sender recibir el ME PC2
		inet_ntop(AF_INET,&(udpClient.sin_addr),ip,INET_ADDRSTRLEN);
	//	clientPort = ntohs(udpClient.sin_port);
		////no se esta recibiendo el buffer que manda el listen en ME PC2....checar
		
		if(strcmp(ip,host)!=0){ //nos aseguramos de no imprimir las respuestas de mi propia IP.
		//fprintf(stderr,"Recibimos: %s desde: [%s:%i]\n",buffer,ip,clientPort);
		
		///Creamos la lista de hosts conocidos con un arreglo de apuntadores a char knownHosts
		for(i=0; i < size; i++) {
   			if(strcmp(knownHosts[i],ip)==0) {
      			  found = 1;
			break;
   			}
		} 

			if(!found) {
			   knownHosts[size] = (char *) malloc(16);
 			   strcpy(knownHosts[size],ip);
   			   size++;
			} 
				
		}	
		
		i=0;
		///En cada respuesta imprimimos la lista de hosts conocidos
		fprintf(stderr,"Hosts conocidos por ");
		while(knownHosts[i]!=NULL){
		
		fprintf(stderr,"%s \n",knownHosts[i]);
		i++;	
		}


		udpClient.sin_port = 5000;
		bzero(buffer,255);
   	    fflush(stdout);
	}
	
	close(udpSocket);
			//exit(0);
			return 0;
		} 
	else {
		//	//SOY EL PADRE
		for(i=0; i<2; i++) {  //Este hilo (proceso) sólo manda WHO IS THERE cada 3 segundos
		status = sendto(bcSock,strbuffer,sendStringLen,0,(struct sockaddr*)&broadcastAddr, sizeof(broadcastAddr));    
      ///Respuestas cada 3 segundos
        sleep(1);   
    	}
		//exit(0);///
		//close(udpSocket); 

	} /////////////////////FIN FORK
		//exit(0);
//close(udpSocket);
fprintf(stderr,"\nElija una IP\n");
gets(chosenip);
fprintf(stderr,"\nUsted escogió al host: %s\n",chosenip );
get_LIST(5000,chosenip); 
fprintf(stderr,"\nAhora teclea el archivo que deseas obtener\n");
gets(filename);
fprintf(stderr,"\nTeclea con qué nombre quieres guardar el archivo\n");
gets(localFilename);
start_client(5000,chosenip,filename,localFilename);
sleep(15); 


return 0;
} //fin main
示例#25
0
文件: pscp.c 项目: JonBau/pscom
void doClient(void)
{
    int forward_id;
    ps_recv_info_t rinfo;
    ps_send_info_t sinfo;
    FILE *output = NULL;
    PSP_PortH_t porth;
    char *buf, *buf2;

    buf = malloc(arg_maxmsize);
    if (!buf) { perror("malloc(buf)"); exit(1); }
    buf2 = malloc(arg_maxmsize);
    if (!buf2) { perror("malloc(buf2)"); exit(1); }

    output = stdout;

    if (arg_ofile) {
	output = fopen(arg_ofile, "w");
	if (!output) {
	    fprintf(stderr, "Cant open file '%s' for writing : %s\n",
		    arg_ofile, strerror(errno));
	    exit(1);
	}
    } else if (arg_ocmd) {
	output = popen(arg_ocmd, "w");
	if (!output) {
	    fprintf(stderr, "Cant start output command '%s' : %s\n",
		    arg_icmd, strerror(errno));
	    exit(1);
	}
    }

    porth = start_client(&forward_id);
    ps_recv_info_init(&rinfo, porth);
    ps_send_info_init(&sinfo, porth, forward_id);
    PSP_StopListen(porth);

    stat_time_start = getusec();
    while (1) {
	int len;
	char *tmp;

	len = ps_recv(&rinfo, buf, arg_maxmsize);
	ps_send(&sinfo, buf, len);

	if (len <= 0) break;
	assert(fwrite(buf, 1, len, output) == (unsigned) len);

	tmp = buf; buf = buf2; buf2 = tmp;

	if (timer_called) {
	    if (arg_manual) print_stat(0);
	    timer_called = 0;
	}
    }

    if (arg_ofile) {
	fclose(output);
    } else if (arg_ocmd) {
	pclose(output);
    }
    ps_recv_close(&rinfo);
    ps_send_close(&sinfo);
    free(buf2);
    free(buf);
}
示例#26
0
bool rvl_connection_new(char *host)
{
	return (host == NULL) ? start_server() : start_client(host);
}
示例#27
0
int main(int argc, char **argv)
{
  qi::Application app(argc, argv);

  std::string usage = "If no mode is specified, run client and server in same process\n";

  po::options_description desc(std::string("Usage:\n ")+argv[0]+"\n" + usage);
  desc.add_options()
    ("help,h", "Print this help.")
    ("all", po::value<std::string>()->default_value("tcp://0.0.0.0:0"), "(default) Run all in the same process.")
    ("client,c", po::value<std::string>(), "Run as a client (tcp://xxx.xxx.xxx.xxx:xxxxx).")
    ("server,s", po::value<std::string>()->implicit_value("tcp://0.0.0.0:0"), "Run as a server.")
    ("gateway", po::value<std::string>(), "Run as a gateway.")
    ("local", "Run in local.")
    ("thread", po::value<int>()->default_value(1, "1"),
     "Number of thread to launch for clients")
    ("valgrind", "Set low loopcount and wait for valgrind.")
    ("gateway", "Run without gateway.")
    ("rstart", po::value<int>()->default_value(0, "0"), "rstart")
    ("rend", po::value<int>()->default_value(20, "20"), "rend")
    ("pipeline", po::value<int>()->default_value(1, "1"), "Max number of parallel calls to run")
    ("threadsafe", po::bool_switch()->default_value(false), "Declare threadsafe service")
    ("msdelay", po::value<int>()->default_value(0, "0"), "Delay in milliseconds to simulate long call")
    ;

  desc.add(qi::details::getPerfOptions());

  po::variables_map vm;
  po::store(po::command_line_parser(argc, argv)
            .options(desc).run(), vm);
  po::notify(vm);

  if (vm.count("help")) {
    std::cout << desc << std::endl;
    return EXIT_SUCCESS;
  }

  if (vm.count("gateway"))
    noGateway = false;

  if (vm.count("valgrind")) {
    gLoopCount = 500;
    valgrind = true;
  }


  if (vm.count("client") + vm.count("server") + !vm["all"].defaulted() + vm.count("gateway") + vm.count("local") > 1) {
    std::cerr << desc << std::endl << "You must put at most one option between [all|client|server|gateway|local]" << std::endl;
    return EXIT_FAILURE;
  }

  if (!vm["thread"].defaulted() && (vm.count("server") != 0 || vm.count("gateway") != 0)) {
    std::cerr << "[thread] is useless with [server] or [gateway]" << std::endl;
  }

  rstart = vm["rstart"].as<int>();
  rend   = vm["rend"].as<int>();
  pipeline = vm["pipeline"].as<int>();
  threadsafe = vm["threadsafe"].as<bool>();
  msDelay = vm["msdelay"].as<int>();

  out = new qi::DataPerfSuite("qimessaging", "transport", qi::DataPerfSuite::OutputData_Period, vm["output"].as<std::string>());

  if (vm.count("client"))
  {
    serverUrl = qi::Url(vm["client"].as<std::string>());
    int threadc = vm["thread"].as<int>();
    start_client(threadc);
  } else if (vm.count("server")) {
    serverUrl = vm["server"].as<std::string>();
    return main_server();
  } else if (vm.count("gateway")) {
    serverUrl = vm["gateway"].as<std::string>();
    return main_gateway(serverUrl);
  } else if (vm.count("local")) {
    return main_local();
  } else {
    //start the server
    int threadc = vm["thread"].as<int>();
    serverUrl = vm["all"].as<std::string>();
    allInOne = true;
    boost::thread threadServer1(boost::bind(&main_server));
    do {
      qi::os::msleep(500); // give it time to listen
    } while (!serverReady); // be nice for valgrind
    if (!noGateway)
      boost::thread threadServer2(boost::bind(&main_gateway, serverUrl));
    qi::os::sleep(1);

    start_client(threadc);
  }

  delete out;

  return EXIT_SUCCESS;
}
示例#28
0
int
start_broker(int num_client, int num_server)
{
    int available_workers = 0;
    char* work_queue[10];
    void* ctx = zmq_ctx_new();
    void* front = zmq_socket(ctx, ZMQ_ROUTER);
    void* back = zmq_socket(ctx, ZMQ_ROUTER);

    zmq_bind(front, "ipc://front.ipc");
    zmq_bind(back, "ipc://back.ipc");

    start_client(num_client);
    start_server(num_server);

    while (1) {
        zmq_pollitem_t items[] = {
            { back, 0, ZMQ_POLLIN, 0 },
            { front, 0, ZMQ_POLLIN, 0 },
        };
        int ret = zmq_poll(items, available_workers ? 2 : 1, -1);
        if (-1 == ret)
            break;

        if (items[0].revents & ZMQ_POLLIN) {
            char client_id[16] = {0};
            char buf[128] = {0};
            char* server_id = (char*)calloc(16, 0);
            zmq_recv(back, server_id, 16, 0);
            work_queue[available_workers++] = server_id;

            zmq_recv(back, buf, sizeof(buf), 0);
            zmq_recv(back, client_id, sizeof(client_id), 0);

            if (0 != strcmp("READY", client_id)) {
                zmq_recv(back, buf, sizeof(buf), 0);

                memset(buf, 0, sizeof(buf));
                zmq_recv(back, buf, sizeof(buf), 0);
                zmq_send(front, client_id, strlen(client_id), ZMQ_SNDMORE);
                zmq_send(front, "", 0, ZMQ_SNDMORE);
                zmq_send(front, buf, strlen(buf), 0);
                if (0 == --num_client)
                    break;
            }
        }

        if (items[1].revents & ZMQ_POLLIN) {
            char client_id[16] = {0};
            char buf[128];
            zmq_recv(front, client_id, sizeof(client_id), 0);
            zmq_recv(front, buf, sizeof(buf), 0);
            memset(buf, 0, sizeof(buf));
            zmq_recv(front, buf, sizeof(buf), 0);

            zmq_send(back, work_queue[0], strlen(work_queue[0]), ZMQ_SNDMORE);
            zmq_send(back, "", 0, ZMQ_SNDMORE);
            zmq_send(back, client_id, strlen(client_id), ZMQ_SNDMORE);
            zmq_send(back, "", 0, ZMQ_SNDMORE);
            zmq_send(back, buf, strlen(buf), 0);

            free(work_queue[0]);
            DEQUE(work_queue);
            --available_workers;
        }
    }

    zmq_close(back);
    zmq_close(front);
    zmq_ctx_destroy(ctx);

    return 0;
}
示例#29
0
JNIEXPORT jint JNICALL Java_cn_edu_hust_buildingtalkback_jni_NativeInterface_startClient(
		JNIEnv *env, jclass clazz)
{
	LOG_FUNC();
	return start_client();
}
示例#30
0
int main(int argc, char *argv[]){
    /* initialize options */
    init_options();

    /* parse command line args */
    int c;
    while((c = getopt(argc, argv, ":hve:p:lku")) != -1){
        switch(c){
            case 'h': help(argv);
                      exit(EXIT_SUCCESS);

            case 'v': o.verbose = 1;
                      break;

            case 'e': o.execcommand = 1;
                      o.command = optarg;
                      break;

            case 'p': o.port = validate_port(optarg);
                      break;

            case 'l': o.listen = 1;
                      break;

            case 'k': o.keepopen = 1;
                      break;

            case 'u': o.udp = 1;
                      break;

            case ':': bye("-%c requires argument\n", optopt);

            /* case ? */
            default: bye("unknown option -%c\n", optopt);

        }/* switch */
    }/* while */

    /* do some checking */

    /* -k specified without -l */
    if(o.keepopen && !o.listen){
        bye("cannot specify -k without -l\n");
    }

    /* -p not specified with -l */
    if(o.listen && !o.port){
        bye("must specify -p with -l\n");
    }


    /* get IP-address and port in case of client mode */
    if(!o.listen && optind < argc){
        o.target = argv[optind++];

        if(optind > argc){
            bye("No port specified\n");
        }

        o.port = validate_port(argv[optind]);

    } else if(!o.listen){
        help(argv);
        exit(EXIT_FAILURE);
    }

    if(o.listen)
        start_server();
    else
        start_client();

    return 0;
}/* main() */