/* s is the file descriptor of a client that has
* pending data. Turn it back into a struct client
* using the lookup table.
* Read data up to 256 characters from the socket.
* Returns the status of the client, true for alive
* or false for dead.
*/
int client_handle(int s)
{
client *c;
char buf[256];
int r;
c = clients[s];
/* Read up to 256 bytes from the client */
r = socket_read(s, buf, 256);
if(r == 0)
{
/* 0 bytes read means the client has disconnected */
client_destroy(s);
return 0;
}
/* Returns whether the buffer has something useful in it */
r = buffer_add(c->buffer, buf, r);
if(r)
{
// printf("Client %d said '%s'\n", s, buffer_get(c->buffer));
parse(s, c);
}
return 1;
}
int socket_main(int hsocket)
{
struct sockaddr_in sock;
int asocket; /* Active socket */
socklen_t sock_len;
char buffer[200];
int got;
sock_len = sizeof(struct sockaddr_in);
asocket = accept( hsocket, (struct sockaddr *)&sock, &sock_len );
if (asocket == -1) {
return -1;
}
socket_write( asocket, "Hi there\n", 9 );
while (1) {
while (socket_poll(asocket)==0) {}
if ((got=socket_read(asocket, buffer, 200))>0) {
socket_write( asocket, buffer, got );
}
else
break;
}
close(asocket);
return 0;
}
size_t nw_readline( nw_socket fd, void *buf, size_t maxlen )
{
size_t n, rc;
char ch;
for (n = 1; n < maxlen; n++)
{
rc = socket_read( fd, &ch, 1 );
if (rc == 1)
{
*((char *) buf)++ = ch;
if (ch == '\n')
break;
}
else if (rc == 0)
{
if (n == 1)
return 0; /* EOF, no data read */
else
break; /* EOF, some data read */
}
else
return -1; /* error */
}
*((char *) buf) = '\0';
return n;
}
static int read_initial_request_line(struct socket_t *socket_p,
char *buf_p,
struct http_server_request_t *request_p)
{
char *action_p = NULL;
char *path_p = NULL;
char *proto_p = NULL;
*buf_p++ = '\0';
action_p = buf_p;
while (1) {
if (socket_read(socket_p,
buf_p,
sizeof(*buf_p)) != sizeof(*buf_p)) {
return (-EIO);
}
buf_p++;
/* The line ending is "\r\n". */
if ((buf_p[-2] == '\r') && (buf_p[-1] == '\n')) {
buf_p[-2] = '\0';
break;
}
/* Action and path has ' ' as terminator. */
if (buf_p[-1] == ' ') {
buf_p[-1] = '\0';
if (path_p == NULL) {
path_p = buf_p;
} else if (proto_p == NULL) {
proto_p = buf_p;
}
}
}
/* A path is required. */
if (path_p == NULL) {
return (-1);
}
log_object_print(NULL,
LOG_DEBUG,
FSTR("%s %s %s\r\n"), action_p, path_p, proto_p);
/* Save the action and path in the request struct. */
strcpy(request_p->path, path_p);
if (strcmp(action_p, "GET") == 0) {
request_p->action = http_server_request_action_get_t;
} else if (strcmp(action_p, "POST") == 0) {
request_p->action = http_server_request_action_post_t;
} else {
return (-1);
}
return (0);
}
static int client_socket_receive( comm_channel_t *channel, char *buf, int len )
{
tcp_connection_t *tc = tcp_get_connection( channel );
int res;
if( !tc )
{
return( -1 );
}
if( !tc->connected )
{
res = client_socket_connect( tc );
}
if( tc->connected )
{
res = socket_read( tc->fd, buf, len );
if( res == -1 )
{
close_connection( tc );
}
}
return( res );
}
void *DoWork(void *test)
{
int new_socket = *((int *) test);
unsigned char buffer[1024];
int len = 0;
logger(LOG_SOCKET, NORMAL, "coming off accept\n");
printf("Sending dat at socket %d\n", new_socket);
const char *data = "Hello World";
socket_send(new_socket, (const unsigned char *) data, 12);
printf("waiting on socket read\n");
#if 0
socket_read(new_socket, buffer, 10);
printf("received from socket %s\n", buffer);
#endif
len = 0;
while(len < 22) {
len += socket_read_nonblock(new_socket, buffer);
if(len < 0) {
printf("socket closed\n");
break;
}
if(len==0) {
printf("nothing to show\n");
}
else {
printf("received from socket %s length %d\n", buffer, len);
}
}
//printf("received from socket %s\n", buffer);
printf("closing socket\n");
socket_close(new_socket);
free(test);
return NULL;
}
bool NameResolution::getIPsFromName(ims::name::IPSet &ips, const std::string &name, ims::name::NameResolutionSourceType sourceType) {
if (name.length() > 0xff) {
// error...
return false;
}
// prepare the command
cmdLen = name.length() + 4;
uint16_t tmpCmdLen = htons(cmdLen);
memcpy(buf, &tmpCmdLen, sizeof(uint16_t));
buf[2] = 0; // type, NameResolution
buf[3] = 0; // function, getIPsFromName
if (sourceType == ims::name::NameResolutionSourceType::ANY) {
buf[4] = 0;
} else if (sourceType == ims::name::NameResolutionSourceType::DNS) {
buf[4] = 1;
}
buf[5] = (unsigned char) name.length();
memcpy(buf + 6, name.c_str(), name.length());
// issue the command
if (socket_write(conn_fd, buf, cmdLen + 2, sockTimeout) != cmdLen + 2) {
// something went wrong...reconnect, try one more time, then fail
close(conn_fd);
if (!establishConnection()) {
return false;
}
if (socket_write(conn_fd, buf, cmdLen + 2, sockTimeout) != cmdLen + 2) {
return false;
}
}
// at this point, all is well, and command has been issued
// read back the # of ips
if (socket_read(conn_fd, (char *) &cmdLen, sizeof(uint16_t), sockTimeout) != sizeof(uint16_t)) {
// error
return false;
}
cmdLen = ntohs(cmdLen);
// FIXME fill a buffer instead of reading one at a time
for (uint16_t i = 0; i < cmdLen; ++i) {
if (socket_read(conn_fd, (char *) &ip, sizeof(uint32_t), sockTimeout) != sizeof(uint32_t)) {
return false;
}
ips.insert(ntohl(ip));
}
return true;
}
bool NameResolution::getNamesFromIP(ims::name::NameSet &names, const uint32_t &ip, ims::name::NameResolutionSourceType sourceType) {
// prepare the command
cmdLen = 7;
uint16_t tmpCmdLen = htons(cmdLen);
memcpy(buf, &tmpCmdLen, sizeof(uint16_t));
buf[2] = 0; // type, NameResolution
buf[3] = 1; // function, getNamesFromIP
this -> ip = htonl(ip);
if (sourceType == ims::name::NameResolutionSourceType::ANY) {
buf[4] = 0;
} else if (sourceType == ims::name::NameResolutionSourceType::DNS) {
buf[4] = 1;
}
memcpy(buf + 5, &(this -> ip), sizeof(uint32_t)); // arg (ip)
// issue the command
if (socket_write(conn_fd, buf, cmdLen + 2, sockTimeout) != cmdLen + 2) {
// something went wrong...reconnect, try one more time, then fail
close(conn_fd);
if (!establishConnection()) {
return false;
}
if (socket_write(conn_fd, buf, cmdLen + 2, sockTimeout) != cmdLen + 2) {
return false;
}
}
// at this point, all is well, and command has been issued
// read back the # of names
if (socket_read(conn_fd, (char *) &cmdLen, sizeof(uint16_t), sockTimeout) != sizeof(uint16_t)) {
// error
return false;
}
cmdLen = ntohs(cmdLen);
// FIXME fill a buffer instead of reading one at a time
for (uint16_t i = 0; i < cmdLen; ++i) {
if (socket_read(conn_fd, (char *) &nameLen, 1, sockTimeout) != 1) {
return false;
}
if (socket_read(conn_fd, buf, nameLen, sockTimeout) != nameLen) {
return false;
}
tmpName.assign(buf, nameLen);
names.insert(tmpName);
}
return true;
}
int32_t execute_segment_stat_handle(struct data_buffer* dbuf,int socket_fd,MEM_POOL* mem_pool)
{
struct data_buffer rbuf;
//发数据包
if(socket_write(socket_fd,dbuf->data,dbuf->data_len) <= 0)
return -1;
//接受命名
memset(&rbuf,0,sizeof(struct data_buffer));
rbuf.data_len = sizeof(uint32_t);
rbuf.size = rbuf.data_len;
rbuf.data = (uint8_t *)mem_pool_malloc(mem_pool,sizeof(uint32_t));
if(socket_read(socket_fd,rbuf.data,rbuf.data_len) <= 0)
return -1;
rbuf.data_len = read_int32(&rbuf);
rbuf.data = (uint8_t *)mem_pool_malloc(mem_pool,rbuf.data_len);
rbuf.rpos = 0;
rbuf.size = rbuf.data_len;
if(socket_read(socket_fd,rbuf.data,rbuf.data_len) <= 0)
return -1;
rbuf.rpos += MESSAGE_HEAD_LEN;
uint16_t type = message_type(&rbuf);
if (type != MT_DC_STAT_RS)
return -1;
uint16_t segment_count = read_int16(&rbuf);
uint16_t i;
fprintf(stderr,"%-20s%-20s%-20s%-20s%-20s%-20s%-20s\n","SEGMENT_ID","CREATE_TIME","MODIFY_TIME","CHECKPOINT_TIME","FLAG","ROW_COUNT","DEL_COUNT");
for(i=0; i<segment_count; i++)
{
fprintf(stderr,"%-20u",read_int16(&rbuf));
fprintf(stderr,"%-20llu",read_int64(&rbuf));
fprintf(stderr,"%-20llu",read_int64(&rbuf));
fprintf(stderr,"%-20llu",read_int64(&rbuf));
fprintf(stderr,"%-20u",read_int8(&rbuf));
fprintf(stderr,"%-20u",read_int32(&rbuf));
fprintf(stderr,"%-20u\n",read_int32(&rbuf));
}
return 0;
}
/*
* Private function name: vnc_send_pointer_event
* Since version: 0.4.2
* Description: Function to send the mouse pointer event/click to VNC window
* Arguments: @server [string]: server string to specify VNC server
* @port [string]: string version of port value to connect to
* @pos_x [int]: position on x-axis of the VNC window
* @pos_y [int]: position on y-axis of the VNC window
* @clicked [int]: mask of what buttons were clicked
* @release [boolean]: release the buttons once clicked
* Returns: 0 on success, -errno otherwise
*/
int vnc_send_pointer_event(char *server, char *port, int pos_x, int pos_y, int clicked, int release)
{
int sfd;
tServerFBParams params;
DPRINTF("%s: Server is %s, port is %s, x is %d, y is %d, clicked is %d, release is %d\n", VNCFUNC,
server, port, pos_x, pos_y, clicked, release);
sfd = vnc_connect(server, port, 0);
if (sfd < 0) {
int err = errno;
DPRINTF("%s: VNC Connection failed with error code %d (%s)\n", VNCFUNC, err, strerror(err));
close(sfd);
return -err;
}
params = vnc_read_server_init(sfd);
if (((pos_x > params.width) || (pos_y < 0))
|| ((pos_y > params.height) || (pos_y < 0))) {
DPRINTF("%s: Required positions out of range (width = %d, height = %d, x = %d, y = %d) for '%s'\n",
VNCFUNC, params.width, params.height, pos_x, pos_y, params.desktopName);
return -EINVAL;
}
socket_read(sfd, -1);
vnc_set_pixel_format(sfd, params);
vnc_set_encoding(sfd);
socket_read(sfd, -1);
usleep(50000);
/* Following paragraph moves mouse pointer to [0, 0] (left upper corner) */
vnc_send_client_pointer(sfd, 0, 0x7FFF, 0x7FFF);
socket_read(sfd, -1);
vnc_send_client_pointer(sfd, 0, 0, 0);
socket_read(sfd, -1);
vnc_send_client_pointer(sfd, clicked, (pos_x / 2), (params.height - pos_y) / 2);
socket_read(sfd, -1);
vnc_send_client_pointer(sfd, 0, (pos_x / 2), ((params.height - pos_y) / 2));
socket_read(sfd, -1);
if (release) {
vnc_send_client_pointer(sfd, clicked, (pos_x / 2), (params.height - pos_y) / 2);
socket_read(sfd, -1);
vnc_send_client_pointer(sfd, 0, (pos_x / 2), (params.height - pos_y) / 2);
socket_read(sfd, -1);
}
shutdown(sfd, SHUT_RDWR);
close(sfd);
DPRINTF("%s: Closed descriptor #%d\n", VNCFUNC, sfd);
return 0;
}
int socket_get( int asocket )
{
char buffer[2];
if (socket_read( asocket, buffer, 1)!=-1) {
return buffer[0];
}
return -1;
}
int main(void) {
// initializing first three investors for program to start with
// initializing_END
int PORT = 5000;
lib_init();
winSock = socket_new();
db_t * db = db_new("teacher.db");
// Checking if socket is not busy, closing app if it is
if (socket_bind(winSock, PORT) == SOCKET_ERROR) {
printf("Cannot bind %i port\n", PORT);
socket_close(winSock);
socket_free(winSock);
return 0;
}
socket_listen(winSock);
char buf[10000];
socket_t * client = NULL;
// main cycle of the program
while (1) {
printf("Awaiting for connections...\n");
client = socket_accept(winSock);
// Checking if client is not null, closing app if he is
if (client == NULL) {
printf("NULL client, closing app...\n");
break;
}
int readStatus = socket_read(client, buf, sizeof(buf));
// Skipping empty request (may appear from time to time)
if (readStatus <= 0) {
printf("Empty request, skipping...\n");
socket_close(client);
socket_free(client);
continue;
}
// Printing info about the received request to console
printf(">> Got request (readStatus: %i):\n'%s'\n", readStatus, buf);
http_request_t request = http_request_parse(buf);
// check the type/path of request (API/HTML) & analyze the method (GET/POST/DELETE)
// and provide the client with proper answer
server_analyzeRequest(&request, client, db);
socket_free(client);
}
// end of program
socket_close(winSock);
socket_free(winSock);
db_free(db);
lib_free();
return 0;
}
int hanclient_send_command_return_res(Client_Command *client_command)
{
int sock,i;
/* Attempt to connect to the han daemon */
if(sockFilePath != NULL)
sock = socket_connect(sockFilePath);
else
sock = socket_connect_ip(inetHost, inetService, PF_UNSPEC, SOCK_STREAM );
if(sock == -1){
debug(DEBUG_ACTION, "Could not open socket to host: %s", inetHost);
return 1;
}
/* Set the socket file mode to non-blocking */
if(fcntl(sock, F_SETFL, O_NONBLOCK) == -1){
debug(DEBUG_ACTION, "Could not set socket to nonblocking");
socket_close(sock);
return 1;
}
/* Write the client command block */
i = socket_write(sock,
(void *) client_command,
sizeof(Client_Command),
USER_WRITE_TIMEOUT);
if(i == 0){
debug(DEBUG_ACTION, "Socket time out error, writing client command");
socket_close(sock);
return 1;
}
debug(DEBUG_ACTION,"packet sent, waiting for response");
/* Wait for, and read back the response */
i = socket_read(sock,
(void *) client_command,
sizeof(Client_Command),
USER_READ_TIMEOUT);
if(i == 0){
debug(DEBUG_ACTION,"Socket time out error, waiting for response");
socket_close(sock);
return 1;
}
/* Close the socket */
socket_close(sock);
return 0;
}
static bool8 NPClientGetROMInfoFromServer (void)
{
if (!npclient.online)
return (false);
NPNotification("Client: Receiving ROM information from server...", -1);
if (NPClientGetMesFromServer() != kNPServerROMInfoWillSend)
{
NPError("Client: Failed to receive messsage from server.", 5201);
return (false);
}
if (NPClientSendMesToServer(kNPClientROMInfoWaiting) == false)
{
NPError("Client: Failed to send messsage to server.", 5202);
return (false);
}
uint8 mes[16];
uint32 l;
if (socket_read(npclient.socket, mes, 16) != 16)
{
NPError("Client: Failed to receive ROM information from server.", 5203);
return (false);
}
nprominfo.crc32 = READ_LONG(mes + 0);
nprominfo.input = READ_LONG(mes + 4);
l = READ_LONG(mes + 12);
if (socket_read(npclient.socket, (uint8 *) nprominfo.fname, l) != (int) l)
{
NPError("Client: Failed to receive ROM name from server.", 5204);
return (false);
}
nprominfo.fname[l] = 0;
nprominfo.length = l;
NPNotification("Client: Received ROM information from server.", -1);
return (true);
}
size_t nw_readbyte( nw_socket fd, nw_byte *d )
{
size_t rc;
rc = socket_read( fd, d, 1 );
if (rc == 1)
return 1;
return rc;
}
/*
* Private function name: vnc_send_keys
* Since version: 0.4.2
* Description: Function to send the key to VNC window
* Arguments: @server [string]: server string to specify VNC server
* @port [string]: string version of port value to connect to
* @keys [string]: string to be send to the guest's VNC window
* Returns: 0 on success, -errno otherwise
*/
int vnc_send_keys(char *server, char *port, char *keys)
{
int sfd;
int i, skip_next;
tServerFBParams params;
DPRINTF("%s: server is %s, port is %s, keys are '%s'\n", VNCFUNC, server, port, keys);
sfd = vnc_connect(server, port, 1);
if (sfd < 0) {
int err = errno;
DPRINTF("%s: VNC Connection failed with error code %d (%s)\n", VNCFUNC, err, strerror(err));
close(sfd);
return -err;
}
params = vnc_read_server_init(sfd);
skip_next = 0;
DPRINTF("%s: About to process key sequence '%s' (%d keys)\n", VNCFUNC, keys, (int)strlen(keys));
for (i = 0; i < strlen(keys); i++) {
DPRINTF("%s: Processing key %d: %d [0x%02x]\n", VNCFUNC, i, keys[i], keys[i]);
if (skip_next) {
skip_next = 0;
continue;
}
/* Handling for escape characters */
if ((keys[i] == '\\') && (strlen(keys) > i + 1)) {
if (keys[i + 1] == 'n')
keys[i] = 13;
if (keys[i + 1] == 'r')
keys[i] = 10;
skip_next = 1;
}
DPRINTF("%s: Sending key press emulation for key %d\n", VNCFUNC, keys[i]);
vnc_send_key(sfd, keys[i], skip_next, 0);
DPRINTF("%s: Requesting framebuffer update\n", VNCFUNC);
vnc_send_framebuffer_update_request(sfd, 1, params);
DPRINTF("%s: Sending key release emulation for key %d\n", VNCFUNC, keys[i]);
vnc_send_key(sfd, keys[i], skip_next, 1);
/* Sleep for 50 ms, required to make VNC server accept the keystroke emulation */
usleep(50000);
}
DPRINTF("%s: All %d keys sent\n", VNCFUNC, (int)strlen(keys));
while (socket_has_data(sfd, 500000, 0) == 1)
socket_read(sfd, -1);
shutdown(sfd, SHUT_RDWR);
close(sfd);
DPRINTF("%s: Closed descriptor #%d\n", VNCFUNC, sfd);
return 0;
}
// physical layer function to send data.
int phy_receive(COMMCTX* ctx, char* buffer, int size)
{
SOCK_CTX* mctx;
mctx=(SOCK_CTX*)ctx->sock_ctx;
return socket_read(mctx->sock, buffer, size);
// dprintf(stderr, "in phy_receive() received %i.\n",ret);
}
static inline oc::result<T> read_copyable_type(int fd)
{
T buf;
OUTCOME_TRY(size, socket_read(fd, &buf, sizeof(T)));
if (size != sizeof(T)) {
return std::errc::io_error;
}
return oc::success(buf);
}
static ssize_t socket_dev_read(dev_cookie cookie, void *buf, off_t pos, ssize_t len)
{
socket_dev *s = (socket_dev *)cookie;
if(s->id >= 0)
return socket_read(s->id, buf, len);
else
return ERR_NET_NOT_CONNECTED;
}
static inline bool read_copyable_type(int fd, TYPE *result)
{
TYPE buf;
if (socket_read(fd, &buf, sizeof(TYPE)) == sizeof(TYPE)) {
*result = buf;
return true;
}
return false;
}
/**
* Check the server for greeting code 220 and then send QUIT and
* check for code 221. If alive return TRUE, else, return FALSE.
*
* @author Jan-Henrik Haukeland, <*****@*****.**>
* @author Michael Amster, <*****@*****.**>
*
* @version \$Id: smtp.c,v 1.14 2004/02/18 22:31:42 chopp Exp $
*
* @file
*/
int check_smtp(Socket_T s) {
int status;
char buf[STRLEN];
char msg[STRLEN];
ASSERT(s);
if(socket_read(s, buf, sizeof(buf)) <= 0) {
log("SMTP: error receiving data -- %s\n", STRERROR);
return FALSE;
}
chomp(buf, STRLEN);
/* RATS: ignore */ /* chomp does zero termination */
sscanf(buf, "%d %s", &status, msg);
if(status != 220) {
log("SMTP error: %s\n", buf);
return FALSE;
}
if(socket_print(s, "QUIT\r\n") < 0) {
log("SMTP: error sending data -- %s\n", STRERROR);
return FALSE;
}
if(socket_read(s, buf, sizeof(buf)) <= 0) {
log("SMTP: error receiving data -- %s\n", STRERROR);
return FALSE;
}
chomp(buf, STRLEN);
/* RATS: ignore */ /* chomp does zero termination */
sscanf(buf, "%d %s", &status, msg);
if(status != 221) {
log("SMTP error: %s\n", buf);
return FALSE;
}
return TRUE;
}
static pid_t read_pid(int fd)
{
pid_t result = 0;
if (-1 == socket_read(fd, (void *)&result, sizeof(pid_t)))
{
perror("bear: read pid");
exit(EXIT_FAILURE);
}
return result;
}
int conn_read(struct connection *conn, struct mbuf *buf)
{
int n = socket_read(conn->fd, buf);
if (n == 0) return CORVUS_EOF;
if (n == CORVUS_ERR) return CORVUS_ERR;
if (n == CORVUS_AGAIN) return CORVUS_AGAIN;
ATOMIC_INC(conn->ctx->stats.recv_bytes, n);
ATOMIC_INC(conn->info->recv_bytes, n);
return CORVUS_OK;
}
int disconnect_error(int fd)
{
char *tmp;
socket_send(fd, "ByeBye");
tmp = socket_read(fd);
close(fd);
free(tmp);
return (1);
}
static bool8 NPServerGetNameFromClient (int c)
{
if (!npplayer[c].online)
return (false);
NPNotification("Server: Receiving player name from client %d...", c);
if (NPServerSendMesToClient(c, kNPServerNameRequest) == false)
{
NPError("Server: Failed to send messsage to client.", 1201);
return (false);
}
uint8 mes[4];
uint32 l;
if (socket_read(npplayer[c].socket, mes, 4) != 4)
{
NPError("Server: Failed to receive name size from client.", 1202);
return (false);
}
l = READ_LONG(mes + 0);
if (socket_read(npplayer[c].socket, (uint8 *) npplayer[c].name, l) != (int) l)
{
NPError("Server: Failed to receive name from client.", 1203);
return (false);
}
npplayer[c].name[l] = 0;
if (NPServerSendMesToClient(c, kNPServerNameReceived) == false)
{
NPError("Server: Failed to send messsage to client.", 1204);
return (false);
}
NPNotification("Server: Received player name from client %d.", c);
return (true);
// next: kNPClientNameSent
}
ssize_t ssl_socket_read(struct ssl_socket_t *self_p,
void *buf_p,
size_t size)
{
BTASSERT(self_p != NULL);
ssl_read_counter++;
return (socket_read(NULL, buf_p, size));
}
int
socket_read_exact(SOCKET s, char * buff, socklen_t bufflen)
{
int bytes;
socklen_t currlen = bufflen;
fd_set read_fds;
struct timeval tm;
int count;
while (currlen > 0) {
// Wait until some data can be read
do {
FD_ZERO( &read_fds );
FD_SET( s, &read_fds );
tm.tv_sec = 0;
tm.tv_usec = 50;
count = select( s + 1, &read_fds, NULL, NULL, &tm);
} while (count == 0);
if( count < 0 ) {
#ifdef WIN32
errno = WSAGetLastError();
#endif
return -1;
} else if( count > 2 ) {
error("socket error in select()\n");
return -1;
}
if( FD_ISSET( s, &read_fds ) ) {
// Try to read some data in
bytes = socket_read(s, buff, currlen);
if (bytes > 0) {
// Adjust the buffer position and size
buff += bytes;
currlen -= bytes;
} else if ( bytes < 0 ) {
#ifdef WIN32
errno = WSAGetLastError();
#endif
if( errno != EWOULDBLOCK) {
//error("socket error.\n");
return -1;
}
} else if (bytes == 0) {
//error("zero bytes read\n");
errno = ENOTCONN;
return -1;
}
}
}
return 0;
}
bool NameResolution::getResolvedIPs(ims::name::IPSet &resolvedIPs, ims::name::NameResolutionSourceType sourceType) {
// prepare the command
cmdLen = 3;
uint16_t tmpCmdLen = htons(cmdLen);
uint32_t count32;
memcpy(buf, &tmpCmdLen, sizeof(uint16_t));
buf[2] = 0; // type, NameResolution
buf[3] = 5; // function, getResolvedIPs
if (sourceType == ims::name::NameResolutionSourceType::ANY) {
buf[4] = 0;
} else if (sourceType == ims::name::NameResolutionSourceType::DNS) {
buf[4] = 1;
}
// issue the command
if (socket_write(conn_fd, buf, cmdLen + 2, sockTimeout) != cmdLen + 2) {
// something went wrong...reconnect, try one more time, then fail
close(conn_fd);
if (!establishConnection()) {
return false;
}
if (socket_write(conn_fd, buf, cmdLen + 2, sockTimeout) != cmdLen + 2) {
return false;
}
}
// at this point, all is well, and command has been issued
// read back the # of ips
if (socket_read(conn_fd, (char *) &count32, sizeof(count32), sockTimeout) != sizeof(count32)) {
// error
return false;
}
count32 = ntohl(count32);
// FIXME fill a buffer instead of reading one at a time
for (uint32_t i = 0; i < count32; ++i) {
if (socket_read(conn_fd, (char *) &ip, sizeof(uint32_t), sockTimeout) != sizeof(uint32_t)) {
return false;
}
resolvedIPs.insert(ntohl(ip));
}
return true;
}
static int NPServerGetMesFromClient (int c)
{
uint8 mes[2];
if (socket_read(npplayer[c].socket, mes, 2) != 2)
return (-1);
if (mes[0] != NP_CLIENT_MAGIC)
return (-1);
return ((int) mes[1]);
}
static int NPClientGetMesFromServer (void)
{
uint8 mes[2];
if (socket_read(npclient.socket, mes, 2) != 2)
return (-1);
if (mes[0] != NP_SERVER_MAGIC)
return (-1);
return ((int) mes[1]);
}
