NSS_STATUS winbindd_send_request(int req_type, struct winbindd_request *request) { struct winbindd_request lrequest; /* Check for our tricky environment variable */ if (winbind_env_set()) { return NSS_STATUS_NOTFOUND; } if (!request) { ZERO_STRUCT(lrequest); request = &lrequest; } /* Fill in request and send down pipe */ init_request(request, req_type); if (write_sock(request, sizeof(*request), request->flags & WBFLAG_RECURSE) == -1) { return NSS_STATUS_UNAVAIL; } if ((request->extra_len != 0) && (write_sock(request->extra_data.data, request->extra_len, request->flags & WBFLAG_RECURSE) == -1)) { return NSS_STATUS_UNAVAIL; } return NSS_STATUS_SUCCESS; }
/* * FTP GET HOME DIR function. Issues a "CWD ~" and "PWD" to * force the ftp daemon to print our our current directory. */ char *ftp_gethomedir(int sock) { char *recvbuf; char *homedir = NULL; write_sock(sock, "CWD ~\n"); recvbuf = read_sock(sock); if(atoi(recvbuf) == 250) { write_sock(sock, "PWD\n"); recvbuf = read_sock(sock); if(atoi(recvbuf) == 257) { char *front, *back; front = strchr(recvbuf, '"'); front++; back = strchr(front, '"'); homedir = Malloc((back - front) * sizeof(char)); strncpy(homedir, front, (back - front)); homedir[(back - front)] = 0x0; } } free(recvbuf); return homedir; }
static void server(int fd) { char buf[70000]; unsigned *ibuf = (unsigned *)buf; uint32_t n; signal(SIGPIPE, SIG_IGN); printf("^"); fflush(stdout); while (1) { if (read_sock(fd, buf, 4) != 4) break; n = ntohl(ibuf[0]); if (n+4 >= sizeof(buf)) { printf("overflow in server!\n"); exit(1); } if (read_sock(fd, buf+4, n) != (int)n) break; n = ntohl(ibuf[1]); ibuf[0] = htonl(n); if (write_sock(fd, buf, n+4) != (int)(n+4)) break; } exit(0); }
int readjpeg(int sock, unsigned char **buf,struct frame_t *headerframe,struct client_t *message,int statOn) { int byteread,bytewrite; bytewrite = write_sock(sock,(unsigned char*)message,sizeof(struct client_t)); // is sleeping ? if ((byteread= read_sock(sock,(unsigned char*)headerframe,sizeof(struct frame_t))) < 0){ printf("Seem server is gone !! try later \n"); goto error; } if(statOn) printf (" key %s nb %d width %d height %d times %dms size %d \n",headerframe->header, headerframe->nbframe,headerframe->w,headerframe->h,headerframe->deltatimes,headerframe->size); if(headerframe->size && !headerframe->wakeup){ //if(headerframe->size){ *buf=(unsigned char*) realloc(*buf,headerframe->size); if((byteread = read_sock(sock,*buf,headerframe->size)) < 0){ printf("Seem server is gone !! try later \n"); goto error;} } //printf("buf read %d \n",byteread); if(headerframe->acknowledge) reset_callbackmessage(message); usleep(5000); return ((headerframe->wakeup)?0:(headerframe->size)); //return (headerframe->size); error: return -1; }
int process_socket(int sock,int inpipe) { fd_set fdset; /* selected file descriptors */ int poll,i; struct timeval tv; signal(SIGPIPE,SIG_IGN); signal(SIGUSR1,trap_reset); listen(sock,5); tv.tv_sec=0; tv.tv_usec=0; poll=0; runloop=1; do { FD_ZERO(&fdset); FD_SET(inpipe,&fdset); if (poll==0) { if (poll_sock(sock,NULL,&fdset) !=0) continue; } else poll_sock(sock,&tv,&fdset); /* open any new connections if possible */ open_sock(sock,&fdset); poll=0; /* check to see if the root server has sent any data */ if (FD_ISSET(inpipe,&fdset)) { int size; size=read(inpipe,mbuf,BUF_SIZE); if (size==0) break; write_raw(mbuf,size); } /* send the data to the clients */ if (write_sock() !=0) poll=1; /* read back any data from the clients */ read_sock(&fdset,tmpbuf,BUF_SIZE); /* decode the buffers here */ } while(runloop); /* close all the clients down */ for (i=0; i<msgmax; i++) { if (client[i].sock !=0) close(client[i].sock); } close(sock); return -1; }
/* * FTP QUIT function. Issues a "QUIT" to terminate the connection. */ int ftp_quit(int sock) { char *recvbuf; write_sock(sock, "QUIT\n"); recvbuf = read_sock(sock); free(recvbuf); close(sock); return 1; }
NSS_STATUS winbindd_send_request(int req_type, int need_priv, struct winbindd_request *request) { struct winbindd_request lrequest; /* Check for our tricky environment variable */ if (winbind_env_set()) { return NSS_STATUS_NOTFOUND; } if (!request) { ZERO_STRUCT(lrequest); request = &lrequest; } /* Fill in request and send down pipe */ init_request(request, req_type); if (write_sock(request, sizeof(*request), request->flags & WBFLAG_RECURSE, need_priv) == -1) { /* Set ENOENT for consistency. Required by some apps */ errno = ENOENT; return NSS_STATUS_UNAVAIL; } if ((request->extra_len != 0) && (write_sock(request->extra_data.data, request->extra_len, request->flags & WBFLAG_RECURSE, need_priv) == -1)) { /* Set ENOENT for consistency. Required by some apps */ errno = ENOENT; return NSS_STATUS_UNAVAIL; } return NSS_STATUS_SUCCESS; }
/* * FTP LOGIN function. Issues a "USER <username> and then "PASS <password>" * to login to the remote host and checks that command succeeded. */ int ftp_login(int sock, char *username, char *password) { char *recvbuf; char *sendbuf; char *header; header = read_sock(sock); printf("\tserver runs:\t%s", header); free(header); sendbuf = Malloc((MAXX(strlen(username), strlen(password)) + 7) * sizeof(char)); sprintf(sendbuf, "USER %s\n", username); write_sock(sock, sendbuf); recvbuf = read_sock(sock); if(atoi(recvbuf) != 331) { free(recvbuf); return 0; } sprintf(sendbuf, "PASS %s\n", password); write_sock(sock, sendbuf); recvbuf = read_sock(sock); if(atoi(recvbuf) != 230) { free(recvbuf); return 0; } free(sendbuf); return 1; }
/* * sends the glob string, to overflow the daemon. */ void send_glob(int sock, char *front) { char globbed[] = "CWD ~/NNNNNN*/X*/X*/X*\n"; int i, j; for(i = 6, j = 0; i < 6 + 6; i++, j++) globbed[i] = front[j]; write_sock(sock, globbed); printf("[5] Globbed commands sent.\n"); free(front); /* start our shell handler */ possibly_rooted(sock); }
void zflush(int finish) { static char outbuf[65536]; zout.next_in = zbuf; zout.avail_in = zbufpos; do { zout.next_out = outbuf; zout.avail_out = sizeof(outbuf); if (deflate(&zout, finish ? Z_FINISH : Z_PARTIAL_FLUSH) == -1) QUIT("zflush : deflate failed !\n"); zsent += sizeof(outbuf) - zout.avail_out; write_sock(outbuf, sizeof(outbuf) - zout.avail_out); } while (zout.avail_out == 0 && zout.avail_in != 0); zbufpos = 0; return; }
int main(int argc, char *argv[]) { signal(SIGINT, sighandler); int retcode; struct sockaddr_in server_sockaddr; unsigned short server_port; char *server_addr; if (argc < 3 || argc > 3) { usage(); } server_addr = argv[1]; server_port = atoi(argv[2]); client_socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); handle_error(client_socket, "socket failed", PROCESS_EXIT); memset(&server_sockaddr, 0, sizeof(server_sockaddr)); server_sockaddr.sin_family = AF_INET; server_sockaddr.sin_addr.s_addr = inet_addr(server_addr); server_sockaddr.sin_port = htons(server_port); retcode = connect(client_socket,(struct sockaddr *) &server_sockaddr,sizeof(server_sockaddr)); handle_error(retcode,"connect failed",PROCESS_EXIT); printf("Mit Server verbunden\n"); char receive_string[BUF_SIZE]; char send_string[BUF_SIZE]; while (1){ memset(send_string, '\0', BUF_SIZE); retcode = fgets(send_string, BUF_SIZE ,stdin); write_sock(client_socket, send_string, strlen(send_string)); memset(receive_string, '\0', BUF_SIZE); retcode = read_sock(client_socket, receive_string, BUF_SIZE); printf("%s\n", receive_string); } }
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; }
/* * FTP CWD function. Issues a "CWD <dirname>" to change directory on * the remote host and checks that the command succeeded. */ int ftp_chdir(int sock, char *dirname) { char *recvbuf; char *sendbuf; sendbuf = Malloc((strlen(dirname) + 6) * sizeof(char)); sprintf(sendbuf, "CWD %s\n", dirname); write_sock(sock, sendbuf); recvbuf = read_sock(sock); free(sendbuf); if(atoi(recvbuf) == 250) { free(recvbuf); return 1; } free(recvbuf); return 0; }
object *socket::write(string *val) { if (socket_val < 0) { exceptions::SocketError *exc = exceptions::SocketError::Create( 1, new string("Socket already closed.") ); exc->throw_exception(); } int ret = write_sock(socket_val, (void*)val->string_val.c_str(), val->string_val.size()); if (ret < 0) { exceptions::SocketError *exc = exceptions::SocketError::Create( 1, new string("Error encountered while writing to socket.") ); exc->throw_exception(); } return new integer(ret); }
int main(int argc, const char * argv[]) { struct sockaddr_in serv_addr; struct hostent *server; int serverSocket = socket(AF_INET, SOCK_STREAM, 0); if(serverSocket < 0) { printf("Cannot open socket.\n"); return 0; } server = gethostbyname("127.0.0.1"); if(server == NULL){ printf("Cannot find server.\n"); return 0; } bzero((char *) &serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; bcopy((char *)server -> h_addr_list[0], (char *) &serv_addr.sin_addr.s_addr, server->h_length); serv_addr.sin_port = htons(5000); if(connect(serverSocket, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) { printf("Cannot connect.\n"); return 0; } //SEND INITIAL MESSAGE TO SERVER STATING THE HOSTS ITEMS write_sock(serverSocket, "C"); //WAIT FOR MESSAGE BACK FROM SERVER char initialMessageFromServer[1024]; int receivedInitialMessageBackFromServer = 0; while(receivedInitialMessageBackFromServer == 0) { int numBytesRead = (int)read(serverSocket, initialMessageFromServer, 1024); if(numBytesRead > 0) { receivedInitialMessageBackFromServer = 1; initialMessageFromServer[numBytesRead] = 0; printf("%s\n", initialMessageFromServer); } } close(serverSocket); //GET MESSAGE FROM USER char portNumber[1024]; printf("ENTER THE PORT NUMBER YOU WANT TO JOIN: "); scanf("%s", portNumber); char clientName[100]; printf("ENTER YOUR USERNAME: "******"%s", clientName); hostSocket = socket(AF_INET, SOCK_STREAM, 0); if(hostSocket < 0) { printf("Cannot open socket.\n"); return 0; } struct sockaddr_in host_addr; struct hostent *hostHost; hostHost = gethostbyname("127.0.0.1"); if(hostHost == NULL) { printf("Cannot find server.\n"); return 0; } bzero((char *) &host_addr, sizeof(host_addr)); serv_addr.sin_family = AF_INET; bcopy((char *)hostHost->h_addr_list[0], (char*)&host_addr.sin_addr.s_addr, hostHost->h_length); host_addr.sin_port = htons(atoi(portNumber)); if(connect(hostSocket, (struct sockaddr*) &host_addr, sizeof(host_addr)) < 0) { printf("Cannot connect.\n"); return 0; } else { int *arg = malloc(sizeof(int)); *arg = hostSocket; struct Client *newClient = malloc(sizeof(struct Client)); newClient->clientSocket = hostSocket; strcpy(newClient->clientName, clientName); pthread_t recvThread, sendThread; pthread_create(&sendThread, NULL, sendtoHost, newClient); pthread_create(&recvThread, NULL, recvFromHost, NULL); pthread_join(sendThread, NULL); pthread_join(recvThread, NULL); } return 0; }
void *read_sock(void *p) { if(p==NULL) return NULL; char szBuf[MAX_SIZE*5] = {0}; SOCKDATA *pdata = (SOCKDATA*)p; int nbytes; if((nbytes=recv(pdata->sock_fd, szBuf, MAX_SIZE, 0))==-1 || nbytes==0){ psyslog(LOG_NOTICE, "From client %d recv data is %s\n", pdata->sock_fd, nbytes?"not empty":"empty"); free(pdata); return NULL; } uint8_t *podata = (uint8_t*)malloc(nbytes-1); if(reverse_crc_data(szBuf, nbytes, (void*)podata)!=0){ psyslog(LOG_ERR, "The data from client crc error"); free(pdata); free(podata); return NULL; } //use JSON cJSON *root = cJSON_Parse((char*)podata); if (root == NULL){ psyslog(LOG_ERR, cJSON_GetErrorPtr()); free(pdata); free(podata); return NULL; } int needResponse = cJSON_GetObjectItem(root, "needResponse")->valueint; char *message = cJSON_GetObjectItem(root, "message")->valuestring; int msgLen = cJSON_GetObjectItem(root, "len")->valueint; bzero(szBuf, MAX_SIZE*5); strncpy(szBuf, message, msgLen); szBuf[msgLen] = '\n'; pthread_rwlock_wrlock(&rwlock); write(pdata->write_fd, szBuf, msgLen+1); if(needResponse) { //need respons bzero(szBuf, MAX_SIZE*5); //nbytes=read(pdata->read_fd, szBuf, MAX_SIZE*5); sleep(0.1); strcpy(szBuf, "Hello WoW!"); nbytes = strlen(szBuf); pdata->msg = szBuf; pdata->size = nbytes; write_sock(pdata); } pthread_rwlock_unlock(&rwlock); free(pdata); free(podata); cJSON_Delete(root); return NULL; }