Ejemplo n.º 1
0
static void
parent_main_loop(void)
{
    thing *t;
    char *url;
    fd_set R2;
    int x;
    struct timeval to;
    FD_ZERO(&R1);
    for (;;) {
	while ((t = get_idle_thing()) && (url = parent_read_url()))
	    dispatch(t, url);
	R2 = R1;
	to.tv_sec = 60;
	to.tv_usec = 0;
	x = select(maxfd + 1, &R2, NULL, NULL, &to);
	if (x < 0) {
	    perror("select");
	    continue;
	} else if (x == 0) {
	    return;
	}
	for (t = things; t; t = t->next) {
	    if (t->state != 1)
		continue;
	    if (!FD_ISSET(t->rfd, &R2))
		continue;
	    read_reply(t);
	}
    }
}
Ejemplo n.º 2
0
void prompt() {
    char cmdBuf[MAX_COMMAND_LEN];

    memset(cmdBuf, 0, MAX_COMMAND_LEN);
    printf("mdb-cli > ");
    fflush(stdout);

    int cmdLen = read(STDIN_FILENO, cmdBuf, MAX_COMMAND_LEN);

    if (cmdLen < 0) {
        /* do nothing */
    }
    //dieWithMessage("read: failed");
    else if (cmdLen == 1) {
        /* empty command. do nothing */
    } else {
        // 发送query请求
        send_to_server(listen_sock, cmdBuf);
        // 读取server返回的结果
        int result = read_reply(listen_sock);

        //客户端请求退出,服务端确认了
        //RESP_CODE_DISCONNECT 代表客户端退出
        if (result == RESP_CODE_DISCONNECT)
            gQuit = 1;
    }
}
Ejemplo n.º 3
0
static int
process_request(cachemgr_request * req)
{
    const struct hostent *hp;
    static struct sockaddr_in S;
    int s;
    int l;
    static char buf[2 * 1024];
    if (req == NULL) {
	auth_html(CACHEMGR_HOSTNAME, CACHE_HTTP_PORT, "");
	return 1;
    }
    if (req->hostname == NULL) {
	req->hostname = xstrdup(CACHEMGR_HOSTNAME);
    }
    if (req->port == 0) {
	req->port = CACHE_HTTP_PORT;
    }
    if (req->action == NULL) {
	req->action = xstrdup("");
    }
    if (!strcmp(req->action, "authenticate")) {
	auth_html(req->hostname, req->port, req->user_name);
	return 0;
    }
    if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
	snprintf(buf, 1024, "socket: %s\n", xstrerror());
	error_html(buf);
	return 1;
    }
    memset(&S, '\0', sizeof(struct sockaddr_in));
    S.sin_family = AF_INET;
    if ((hp = gethostbyname(req->hostname)) != NULL) {
	assert(hp->h_length <= sizeof(S.sin_addr.s_addr));
	xmemcpy(&S.sin_addr.s_addr, hp->h_addr, hp->h_length);
    } else if (safe_inet_addr(req->hostname, &S.sin_addr))
	(void) 0;
    else {
	snprintf(buf, 1024, "Unknown host: %s\n", req->hostname);
	error_html(buf);
	return 1;
    }
    S.sin_port = htons(req->port);
    if (connect(s, (struct sockaddr *) &S, sizeof(struct sockaddr_in)) < 0) {
	snprintf(buf, 1024, "connect: %s\n", xstrerror());
	error_html(buf);
	return 1;
    }
    l = snprintf(buf, sizeof(buf),
	"GET cache_object://%s/%s HTTP/1.0\r\n"
	"Accept: */*\r\n"
	"%s"			/* Authentication info or nothing */
	"\r\n",
	req->hostname,
	req->action,
	make_auth_header(req));
    write(s, buf, l);
    debug(1) fprintf(stderr, "wrote request: '%s'\n", buf);
    return read_reply(s, req);
}
Ejemplo n.º 4
0
NSS_STATUS winbindd_get_response(struct winbindd_response *response)
{
	struct winbindd_response lresponse;

	if (!response) {
		ZERO_STRUCT(lresponse);
		response = &lresponse;
	}

	init_response(response);

	/* Wait for reply */
	if (read_reply(response) == -1) {
		return NSS_STATUS_UNAVAIL;
	}

	/* Throw away extra data if client didn't request it */
	if (response == &lresponse) {
		free_response(response);
	}

	/* Copy reply data from socket */
	if (response->result != WINBINDD_OK) {
		return NSS_STATUS_NOTFOUND;
	}
	
	return NSS_STATUS_SUCCESS;
}
Ejemplo n.º 5
0
static void
read_data_cb (GObject *object, GAsyncResult *res, gpointer user_data)
{
  GInputStream *input = G_INPUT_STREAM (object);
  GVfsAfpConnection *afp_connection = G_VFS_AFP_CONNECTION (user_data);
  GVfsAfpConnectionPrivate *priv = afp_connection->priv;

  gboolean result;
  GError *err = NULL;

  if (g_atomic_int_get (&priv->atomic_state) == STATE_PENDING_CLOSE)
  {
    if (!priv->send_loop_running)
      close_connection (afp_connection);
    return;
  }
  
  result = read_all_finish (input, res, NULL, &err);
  if (!result)
  {
    g_warning ("FAIL!!! \"%s\"\n", err->message);
    g_error_free (err);
  }

  dispatch_reply (afp_connection);

  if (priv->free_reply_buf)
    g_free (priv->reply_buf);
  priv->reply_buf = NULL;
  
  read_reply (afp_connection);
}
Ejemplo n.º 6
0
static void
read_dsi_header_cb (GObject *object, GAsyncResult *res, gpointer user_data)
{
  GInputStream *input = G_INPUT_STREAM (object);
  GVfsAfpConnection *afp_conn = G_VFS_AFP_CONNECTION (user_data);
  GVfsAfpConnectionPrivate *priv = afp_conn->priv;
  
  gboolean result;
  GError *err = NULL;
  DSIHeader *dsi_header;

  if (g_atomic_int_get (&priv->atomic_state) == STATE_PENDING_CLOSE)
  {
    if (!priv->send_loop_running)
      close_connection (afp_conn);
    return;
  }
  
  result = read_all_finish (input, res, NULL, &err);
  if (!result)
  {
    g_warning ("FAIL!!! \"%s\"\n", err->message);
    g_error_free (err);
  }

  dsi_header = &priv->read_dsi_header;
  
  dsi_header->requestID = GUINT16_FROM_BE (dsi_header->requestID);
  dsi_header->errorCode = GUINT32_FROM_BE (dsi_header->errorCode);
  dsi_header->totalDataLength = GUINT32_FROM_BE (dsi_header->totalDataLength);
  
  if (dsi_header->totalDataLength > 0)
  {
    RequestData *req_data;

    req_data = g_hash_table_lookup (priv->request_hash,
                                    GUINT_TO_POINTER ((guint)dsi_header->requestID));
    if (req_data && req_data->reply_buf)
    {
        priv->reply_buf = req_data->reply_buf;
        priv->free_reply_buf = FALSE;
    }
    else
    {
      priv->reply_buf = g_malloc (dsi_header->totalDataLength);
      priv->free_reply_buf = TRUE;
    }
    
    read_all_async (input, priv->reply_buf, dsi_header->totalDataLength,
                    0, priv->read_cancellable, read_data_cb, afp_conn);
    
    return;
  }

  dispatch_reply (afp_conn);
  read_reply (afp_conn);
}
Ejemplo n.º 7
0
short shrimp_gateway_impl::get_steer() {
    shrimp_command_t command(STEER, read_t);
    send_command(command);
    if (read_reply()) {
        return m_reply;
    }
    else
        return 0;
}
Ejemplo n.º 8
0
short shrimp_gateway_impl::get_speed() {
    shrimp_command_t command(SPEED, read_t);
    send_command(command);
    if (read_reply()) {
        return m_reply;
    }
    else
        return 0;
}
Ejemplo n.º 9
0
extern Success send_command (Stream s, Connection_Id id)
{
  SEND_HEADER (A_DATA);
  if (read_reply (s) == NONE)
    return ERROR;
  if (forward_data (0, s, TRUE) == OK &&
      forward_data (s, 1, FALSE) == OK)
    return OK;
  else
    return ERROR;
}
Ejemplo n.º 10
0
extern Success open_connection (Stream s, const char *host, int port)
{
  if (send_open_header (s, host, port) == ERROR)
    return ERROR;
  {
    Connection_Id id = read_reply (s);
    if (id == NONE)
      return ERROR;
    printf ("%d\n", id);
  }
  return OK;
}
Ejemplo n.º 11
0
int main(int argc, char *argv[])
{
	int i;

	test_init(argc, argv);

	fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
	if (fd<0){
		pr_perror("socket");
		goto out;
	}
	// setup local address & bind using
	// this address
	bzero(&la, sizeof(la));
	la.nl_family = AF_NETLINK;
	la.nl_pid = getpid();
	if (bind(fd, (struct sockaddr*) &la, sizeof(la))){
		pr_perror("bind failed");
		goto out;
	}
	//Preperation:
	form_request_del();
	send_request();
	recv_reply();

	test_daemon();

	while (test_go()){
		for (i=0; i < CMD_NUM; i++){
			cmd[i]();
			if (send_request() < 0){
				fail("send_request failed");
				goto out;
			};
			if (recv_reply() < 0){
				fail("RTNETLINK answers: %m");
				goto out;
			};

#ifdef DEBUG
			if (read_reply() < 0){
				fail("read_reply failed");
				goto out;
			}
#endif
		}
	}

	pass();

out:
	return 0;
}
Ejemplo n.º 12
0
static void
run_loop (GVfsAfpConnection *afp_connection)
{
  GVfsAfpConnectionPrivate *priv = afp_connection->priv;

  if (!priv->send_loop_running)
  {
    priv->send_loop_running = TRUE;
    send_request (afp_connection);
  }
  if (!priv->read_loop_running)
  {
    priv->read_loop_running = TRUE;
    read_reply (afp_connection);
  }
}
Ejemplo n.º 13
0
int main(int argc, char* argv[])
{
  try
  {
    log_init();

    cxxtools::Arg<const char*> ip(argc, argv, 'i', "0.0.0.0");
    cxxtools::Arg<unsigned short> port(argc, argv, 'p', 1234);
    cxxtools::Arg<unsigned> bufsize(argc, argv, 'b', 8192);
    cxxtools::Arg<bool> listen(argc, argv, 'l');
    cxxtools::Arg<bool> read_reply(argc, argv, 'r');

    if (listen)
    {
      // I'm a server

      // listen to a port
      cxxtools::net::Server server(ip.getValue(), port);

      // accept a connetion
      cxxtools::net::iostream worker(server, bufsize);

      // copy to stdout
      std::cout << worker.rdbuf();
    }
    else
    {
      // I'm a client

      // connect to server
      cxxtools::net::iostream peer(ip, port, bufsize);

      // copy stdin to server
      peer << std::cin.rdbuf() << std::flush;

      if (read_reply)
        // copy answer to stdout
        std::cout << peer.rdbuf() << std::flush;
    }
  }
  catch (const std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }
}
Ejemplo n.º 14
0
/**
 * Get login details from user and
 * send to server for authentication
 */
void ftclient_login()
{
	struct command cmd;
	char user[256];
	memset(user, 0, 256);

	// Get username from user
	printf("Name: ");	
	fflush(stdout); 		
	read_input(user, 256);

	// Send USER command to server
	strcpy(cmd.code, "USER");
	strcpy(cmd.arg, user);
	ftclient_send_cmd(&cmd);
	
	// Wait for go-ahead to send password
	int wait;
	recv(sock_control, &wait, sizeof wait, 0);

	// Get password from user
	fflush(stdout);	
	char *pass = getpass("Password: "******"PASS");
	strcpy(cmd.arg, pass);
	ftclient_send_cmd(&cmd);
	
	// wait for response
	int retcode = read_reply();
	switch (retcode) {
		case 430:
			printf("Invalid username/password.\n");
			exit(0);
		case 230:
			printf("Successful login.\n");
			break;
		default:
			perror("error reading message from server");
			exit(1);		
			break;
	}
}
Ejemplo n.º 15
0
static bool upload(const char* addr, const char* filepath)
{
	acl::socket_stream conn;
	if (conn.open(addr, 30, 30) == false)
	{
		printf("connect %s error %s\r\n", addr, acl::last_serror());
		return false;
	}

	if (handshake(conn) == false)
		return false;

	acl::websocket ws(conn);

	if (send_file(ws, filepath) == false)
		return false;

	if (read_reply(ws) == false)
		return false;
	return true;
}
Ejemplo n.º 16
0
static int pam_winbind_request(enum winbindd_cmd req_type,
			       struct winbindd_request *request,
			       struct winbindd_response *response)
{

	/* Fill in request and send down pipe */
	init_request(request, req_type);
	
	if (write_sock(request, sizeof(*request)) == -1) {
		_pam_log(LOG_ERR, "write to socket failed!");
		close_sock();
		return PAM_SERVICE_ERR;
	}
	
	/* Wait for reply */
	if (read_reply(response) == -1) {
		_pam_log(LOG_ERR, "read from socket failed!");
		close_sock();
		return PAM_SERVICE_ERR;
	}

	/* We are done with the socket - close it and avoid mischeif */
	close_sock();

	/* Copy reply data from socket */
	if (response->result != WINBINDD_OK) {
		if (response->data.auth.pam_error != PAM_SUCCESS) {
			_pam_log(LOG_ERR, "request failed: %s, PAM error was %d, NT error was %s", 
				 response->data.auth.error_string,
				 response->data.auth.pam_error,
				 response->data.auth.nt_status_string);
			return response->data.auth.pam_error;
		} else {
			_pam_log(LOG_ERR, "request failed, but PAM error 0!");
			return PAM_SERVICE_ERR;
		}
	}
	
	return PAM_SUCCESS;
}
Ejemplo n.º 17
0
static void
read_data_cb (GObject *object, GAsyncResult *res, gpointer user_data)
{
  GInputStream *input = G_INPUT_STREAM (object);
  GVfsAfpConnection *afp_connection = G_VFS_AFP_CONNECTION (user_data);
  GVfsAfpConnectionPrivate *priv = afp_connection->priv;

  gboolean result;
  GError *err = NULL;

  result = read_all_finish (input, res, NULL, &err);
  if (!result)
  {
    g_warning ("FAIL!!! \"%s\"\n", err->message);
    g_error_free (err);
  }

  dispatch_reply (afp_connection);

  if (priv->free_reply_buf)
    g_free (priv->reply_buf);
  
  read_reply (afp_connection);
}
Ejemplo n.º 18
0
int main(int argc, char* argv[]) 
{		
	int data_sock, retcode, s;
	char buffer[MAXSIZE];
	struct command cmd;	
	struct addrinfo hints, *res, *rp;

	if (argc != 3) {
		printf("usage: ./ftclient hostname port\n");
		exit(0);
	}

	char *host = argv[1];
	char *port = argv[2];


	/* Get matching addresses */
	memset(&hints, 0, sizeof(struct addrinfo));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	
	s = getaddrinfo(host, port, &hints, &res);
	if (s != 0) {
		printf("getaddrinfo() error %s", gai_strerror(s));
		exit(1);
	}
	
	/* Find an address to connect to & connect */
	for (rp = res; rp != NULL; rp = rp->ai_next) {
		sock_control = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);

		if (sock_control < 0)
			continue;

		if(connect(sock_control, res->ai_addr, res->ai_addrlen)==0) {
			break;
		} else {
			perror("connecting stream socket");
			exit(1);
		}
		close(sock_control);
    }    
	freeaddrinfo(rp);


	/* Get connection, welcome messages */
	printf("Connected to %s.\n", host);
	print_reply(read_reply()); 
	

	/* Get name and password and send to server */
	ftclient_login();

	while (1) { /* loop until user types quit */

		// Get a command from user
		if ( ftclient_read_command(buffer, sizeof buffer, &cmd) < 0) {
			printf("Invalid command\n");
			continue;	// loop back for another command
		}

		// Send command to server
		if (send(sock_control, buffer, (int)strlen(buffer), 0) < 0 ) {
			close(sock_control);
			exit(1);
		}

		retcode = read_reply();		
		if (retcode == 221) {
			/* If command was quit, just exit */
			print_reply(221);		
			break;
		}
		
		if (retcode == 502) {
			/* If invalid command, show error message */
			printf("%d Invalid command.\n", retcode);
		} else {			
			/* Command is valid (RC = 200), process command */
		
			/* open data connection */
			if ((data_sock = ftclient_open_conn(sock_control)) < 0){
				perror("Error opening socket for data connection");
				exit(1);
			}			
			
			// execute command
			if (strcmp(cmd.code, "LIST") == 0) {
				ftclient_list(data_sock, sock_control);
			} 
			else if (strcmp(cmd.code, "RETR") == 0) {
				// wait for reply (is file valid)
				if (read_reply() == 550) {
					print_reply(550);		
					close(data_sock);
					continue; 
				}
				ftclient_get(data_sock, sock_control, cmd.arg);
				print_reply(read_reply()); 
			}
			close(data_sock);
		}

	} // loop back to get more user input

	/* Close the socket (control connection) */
	close(sock_control);
    return 0;  
}
Ejemplo n.º 19
0
static gpointer
open_thread_func (gpointer user_data)
{
  SyncData *data = user_data;
  GVfsAfpConnection *conn = data->conn;
  GVfsAfpConnectionPrivate *priv = conn->priv;

  GSocketClient *client;

  guint16 req_id;
  gboolean res = FALSE;
  char *reply;
  DSIHeader dsi_header;
  guint pos;

  client = g_socket_client_new ();
  priv->stream = G_IO_STREAM (g_socket_client_connect (client, priv->addr, data->cancellable,
                                                       data->error));
  g_object_unref (client);

  if (!priv->stream)
    goto out;

  req_id = get_request_id (conn);
  res = send_request_sync (g_io_stream_get_output_stream (priv->stream),
                           DSI_OPEN_SESSION, req_id, 0,  0, NULL,
                           data->cancellable, data->error);
  if (!res)
    goto out;

  res = read_reply_sync (g_io_stream_get_input_stream (priv->stream),
                         &dsi_header, &reply, data->cancellable, data->error);
  if (!res)
    goto out;

  pos = 0;
  while ((dsi_header.totalDataLength - pos) > 2)
  {
    guint8 optionType;
    guint8 optionLength;

    optionType = reply[pos++];
    optionLength = reply[pos++];

    switch (optionType)
    {
      
      case 0x00:
        if (optionLength == 4 && (dsi_header.totalDataLength - pos) >= 4)
          priv->kRequestQuanta = GUINT32_FROM_BE (*(guint32 *)(reply + pos));

        break;
        
      case 0x02:
        if (optionLength == 4 && (dsi_header.totalDataLength - pos) >= 4)
         priv->kServerReplayCacheSize = GUINT32_FROM_BE (*(guint32 *)(reply + pos));

        break;
      

      default:
        g_debug ("Unknown DSI option\n");
    }

    pos += optionLength;
  }
  g_free (reply);

out:
  if (res)
    g_atomic_int_set (&priv->atomic_state, STATE_CONNECTED);
  
  /* Signal sync call thread */
  data->res = res;
  sync_data_signal (data);

  /* Return from thread on failure */
  if (!res)
  {
    g_clear_object (&priv->stream);
    return NULL;
  }
  
  /* Create MainLoop */
  priv->worker_context = g_main_context_new ();
  priv->worker_loop = g_main_loop_new (priv->worker_context, TRUE);

  read_reply (conn);
  
  /* Run mainloop */
  g_main_loop_run (priv->worker_loop);

  return NULL;
}
Ejemplo n.º 20
0
static int conv_fn(int num_msg, PAM_CONST struct pam_message** msg_,
                   struct pam_response** resp_, void* appdata_ptr)
{
  if (num_msg <= 0 || num_msg > PAM_MAX_NUM_MSG) return PAM_CONV_ERR;

  debug("(%sPAM conversation called)", pam_conv_fd < 0 ? "Null " : "");

  struct pam_response* resp = malloc(num_msg * sizeof(*resp));
  if (!resp) return PAM_BUF_ERR;

  int i;
  for (i = 0; i < num_msg; ++i) {
#ifdef SUN_PAM
    /* In Sun-derived libpam, "pam_message**" is a pointer to an array. */
    struct pam_message* msg = &((*msg_)[i]);
#else
    /* It's an array of pointers otherwise. */
    PAM_CONST struct pam_message* msg = msg_[i];
#endif
    resp[i].resp_retcode = 0;
    resp[i].resp = 0;
    switch (msg->msg_style) {
    case PAM_PROMPT_ECHO_OFF:
    case PAM_PROMPT_ECHO_ON:
      debug("  Prompt(e=%d): %s",
            msg->msg_style==PAM_PROMPT_ECHO_OFF ? 0 : 1,
            msg->msg);
      if (pam_conv_fd >= 0) {
        if (conv_reject_prompts) goto bail;
        if (write_text(pam_conv_fd, msg->msg) < 0 ||
            write_prompt(pam_conv_fd, msg->msg_style == PAM_PROMPT_ECHO_ON) < 0)
          goto bail;
        resp[i].resp = read_reply(pam_conv_fd);
        if (!resp[i].resp) goto bail;
        if (strlen(resp[i].resp)+1 > PAM_MAX_RESP_SIZE) goto bail;
      }
      break;
    case PAM_ERROR_MSG:
    case PAM_TEXT_INFO:
      debug("  %s: %s",
            msg->msg_style==PAM_ERROR_MSG ? "Error" : "Info",
            msg->msg);
      if (pam_conv_fd >= 0) {
        if (write_text(pam_conv_fd, msg->msg) < 0)
          goto bail;
        size_t len = strlen(msg->msg);
        if (len > 0 && msg->msg[len-1] != '\n' &&
            write_text(pam_conv_fd, "\n") < 0)
          goto bail;
      }
      break;
    default:
      goto bail;
    }
  }

  if (pam_conv_fd >= 0) {
    *resp_ = resp;
    return PAM_SUCCESS;
  }

  if (i == num_msg) i = num_msg-1;

bail:
  for (; i >= 0; --i) {
    if (!resp[i].resp) continue;
    buffer_scrub(resp[i].resp, strlen(resp[i].resp));
    free(resp[i].resp);
  }
  buffer_scrub(resp, num_msg * sizeof(*resp));
  free(resp);

  return PAM_CONV_ERR;
}
Ejemplo n.º 21
0
extern Success close_connection (Stream s, Connection_Id id)
{
  SEND_HEADER (A_CLOSE);
  return (read_reply (s) == OK ? OK : ERROR);
}
Ejemplo n.º 22
0
int main(int argc, char* argv[])
{
  try
  {
    log_init();

    cxxtools::Arg<std::string> ip(argc, argv, 'i');
    cxxtools::Arg<unsigned short> port(argc, argv, 'p', 1234);
    cxxtools::Arg<unsigned> bufsize(argc, argv, 'b', 8192);
    cxxtools::Arg<bool> listen(argc, argv, 'l');
    cxxtools::Arg<bool> read_reply(argc, argv, 'r');
    cxxtools::Arg<bool> ssl(argc, argv, 's');
    cxxtools::Arg<std::string> cert(argc, argv, "--cert");
    cxxtools::Arg<std::string> ca(argc, argv, "--CA");

    if (listen)
    {
      // I'm a server

      // listen to a port
      cxxtools::net::TcpServer server(ip.getValue(), port);

      // accept a connetion
      cxxtools::net::TcpStream worker(server, bufsize);

      if (ssl)
      {
          if (cert.isSet())
              worker.loadSslCertificateFile(cert);
          if (ca.isSet())
              worker.setSslVerify(2, ca);
          worker.sslAccept();
      }

      // copy to stdout
      std::cout << worker.rdbuf();
    }
    else
    {
      // I'm a client

      // connect to server
      cxxtools::net::TcpStream peer(ip, port, bufsize);

      if (ssl)
      {
          if (cert.isSet())
              peer.loadSslCertificateFile(cert);
          peer.sslConnect();
      }

      if (argc > 1)
      {
          for (int a = 1; a < argc; ++a)
          {
              std::ifstream in(argv[a]);
              peer << in.rdbuf() << std::flush;
          }
      }
      else
      {
          // copy stdin to server
          peer << std::cin.rdbuf() << std::flush;
      }

      if (read_reply)
        // copy answer to stdout
        std::cout << peer.rdbuf() << std::flush;
    }
  }
  catch (const std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }
}