void start_auth(struct Client* client) { struct AuthRequest* auth = 0; assert(0 != client); if (conf_check_slines(client)) { sendheader(client, REPORT_USING_SLINE); SetSLined(client); release_auth_client(client); return; } auth = make_auth_request(client); assert(0 != auth); Debug((DEBUG_INFO, "Beginning auth request on client %p", client)); if (!feature_bool(FEAT_NODNS)) { if (LOOPBACK == inet_netof(cli_ip(client))) strcpy(cli_sockhost(client), cli_name(&me)); else { struct DNSQuery query; query.vptr = auth; query.callback = auth_dns_callback; if (IsUserPort(auth->client)) sendheader(client, REPORT_DO_DNS); cli_dns_reply(client) = gethost_byaddr((const char*) &(cli_ip(client)), &query); if (cli_dns_reply(client)) { ++(cli_dns_reply(client))->ref_count; ircd_strncpy(cli_sockhost(client), cli_dns_reply(client)->hp->h_name, HOSTLEN); if (IsUserPort(auth->client)) sendheader(client, REPORT_FIN_DNSC); Debug((DEBUG_LIST, "DNS entry for %p was cached", auth->client)); } else SetDNSPending(auth); } } if (start_auth_query(auth)) { Debug((DEBUG_LIST, "identd query for %p initiated successfully", auth->client)); link_auth_request(auth, &AuthPollList); } else if (IsDNSPending(auth)) { Debug((DEBUG_LIST, "identd query for %p not initiated successfully; " "waiting on DNS", auth->client)); link_auth_request(auth, &AuthIncompleteList); } else { Debug((DEBUG_LIST, "identd query for %p not initiated successfully; " "no DNS pending; releasing immediately", auth->client)); free_auth_request(auth); release_auth_client(client); } }
/* * destroy_auth_request - stop an auth request completely */ void destroy_auth_request(struct AuthRequest* auth, int send_reports) { struct AuthRequest** authList; if (IsDoingAuth(auth)) { authList = &AuthPollList; if (-1 < auth->fd) { close(auth->fd); auth->fd = -1; socket_del(&auth->socket); } if (send_reports && IsUserPort(auth->client)) sendheader(auth->client, REPORT_FAIL_ID); } else authList = &AuthIncompleteList; if (IsDNSPending(auth)) { delete_resolver_queries(auth); if (send_reports && IsUserPort(auth->client)) sendheader(auth->client, REPORT_FAIL_DNS); } if (send_reports) { log_write(LS_RESOLVER, L_INFO, 0, "DNS/AUTH timeout %s", get_client_name(auth->client, HIDE_IP)); release_auth_client(auth->client); } unlink_auth_request(auth, authList); free_auth_request(auth); }
void senddata(char *url,int clientsocket,int redirect) { int i,count=0; char c; FILE *fp, *fp1; time_t tim; struct stat size; char buffer[1024]; bzero(buffer,1024); fp1 = fopen("logs","a"); printf("I am send Data \n"); if(redirect != 1) { fp = fopen(url,"rb"); printf("\nfile %s\n",url); if(fp == NULL) { if(errno == 13) { sendheader(403,&url,clientsocket); printf("Not autharised\n"); fp = fopen(url,"rb"); } else if(errno == 2) { sendheader(400,&url,clientsocket); printf("Could not find file %s %d\n",url,errno); perror("fopen"); fp = fopen(url,"rb"); } } else sendheader(200,&url,clientsocket); } else { sendheader(301,&url,clientsocket); fp = fopen(url,"rb"); } printf("\nfile %s\n",url); stat(url,&size); printf("%d\n",size.st_size); while(count < size.st_size) { for(i = 0; i< 1023&&count < size.st_size; i++,count++) { buffer[i] = fgetc(fp); fprintf(fp1,"%c",c); } write(clientsocket,buffer,strlen(buffer)); bzero(buffer,1024); } fclose(fp); fclose(fp1); printf("End\n"); }
/* * authsenderr - handle auth send errors */ static void auth_error(struct AuthRequest* auth, int kill) { ++ServerStats->is_abad; assert(0 != auth); close(auth->fd); auth->fd = -1; socket_del(&auth->socket); if (IsUserPort(auth->client)) sendheader(auth->client, REPORT_FAIL_ID); if (kill) { /* * we can't read the client info from the client socket, * close the client connection and free the client * Need to do this before we ClearAuth(auth) so we know * which list to remove the query from. --Bleep */ auth_kill_client(auth); return; } ClearAuth(auth); unlink_auth_request(auth, &AuthPollList); if (IsDNSPending(auth)) link_auth_request(auth, &AuthIncompleteList); else { release_auth_client(auth->client); free_auth_request(auth); } }
/* * read_auth_reply - read the reply (if any) from the ident server * we connected to. * We only give it one shot, if the reply isn't good the first time * fail the authentication entirely. --Bleep */ void read_auth_reply(struct AuthRequest* auth) { char* username = 0; unsigned int len; /* * rfc1453 sez we MUST accept 512 bytes */ char buf[BUFSIZE + 1]; assert(0 != auth); assert(0 != auth->client); assert(auth == cli_auth(auth->client)); if (IO_SUCCESS == os_recv_nonb(auth->fd, buf, BUFSIZE, &len)) { buf[len] = '\0'; Debug((DEBUG_LIST, "Auth %p [%p] reply: %s", auth, &auth->socket, buf)); username = check_ident_reply(buf); Debug((DEBUG_LIST, "Username: %s", username)); } close(auth->fd); auth->fd = -1; Debug((DEBUG_LIST, "Deleting auth [%p] socket %p", auth, &auth->socket)); socket_del(&auth->socket); ClearAuth(auth); if (!EmptyString(username)) { ircd_strncpy(cli_username(auth->client), username, USERLEN); /* * Not needed, struct is zeroed by memset * auth->client->username[USERLEN] = '\0'; */ SetGotId(auth->client); ++ServerStats->is_asuc; if (IsUserPort(auth->client)) sendheader(auth->client, REPORT_FIN_ID); } else { ++ServerStats->is_abad; } unlink_auth_request(auth, &AuthPollList); if (IsDNSPending(auth)) link_auth_request(auth, &AuthIncompleteList); else { release_auth_client(auth->client); free_auth_request(auth); } }
int main() { fd_set rs,ws,rfds,wfds; memset(u,'\0',sizeof(u)); bzero(&rs, sizeof(fd_set)); bzero(&ws, sizeof(fd_set)); bzero(&rfds, sizeof(fd_set)); bzero(&wfds, sizeof(fd_set)); char teststr[]="h1=127.0.0.1&p1=8899&f1=t5.txt&h2=&p2=&f2=&h3=&p3=&f3=&h4=&p4=&f4=&h5=&p5=&f5="; // parser(teststr); parser(getenv("QUERY_STRING")); sendheader(); setsocket(&rs,&ws); setselect(&rs,&ws,&rfds,&wfds); // sleep(10); return 0; }
/* * start_auth_query - Flag the client to show that an attempt to * contact the ident server on the client's host. The connect and * subsequently the socket are all put into 'non-blocking' mode. * Should the connect or any later phase of the identifing process fail, * it is aborted and the user is given a username of "unknown". */ static int start_auth_query(struct AuthRequest* auth) { struct sockaddr_in remote_addr; struct sockaddr_in local_addr; int fd; IOResult result; assert(0 != auth); assert(0 != auth->client); if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { ++ServerStats->is_abad; return 0; } if ((MAXCONNECTIONS - 10) < fd) { close(fd); return 0; } if (!os_set_nonblocking(fd)) { close(fd); return 0; } if (IsUserPort(auth->client)) sendheader(auth->client, REPORT_DO_ID); /* * get the local address of the client and bind to that to * make the auth request. This used to be done only for * ifdef VIRTTUAL_HOST, but needs to be done for all clients * since the ident request must originate from that same address-- * and machines with multiple IP addresses are common now */ memset(&local_addr, 0, sizeof(struct sockaddr_in)); os_get_sockname(cli_fd(auth->client), &local_addr); local_addr.sin_port = htons(0); if (bind(fd, (struct sockaddr*) &local_addr, sizeof(struct sockaddr_in))) { close(fd); return 0; } remote_addr.sin_addr.s_addr = (cli_ip(auth->client)).s_addr; remote_addr.sin_port = htons(113); remote_addr.sin_family = AF_INET; if ((result = os_connect_nonb(fd, &remote_addr)) == IO_FAILURE || !socket_add(&auth->socket, auth_sock_callback, (void*) auth, result == IO_SUCCESS ? SS_CONNECTED : SS_CONNECTING, SOCK_EVENT_READABLE, fd)) { ServerStats->is_abad++; /* * No error report from this... */ close(fd); if (IsUserPort(auth->client)) sendheader(auth->client, REPORT_FAIL_ID); return 0; } auth->flags |= AM_SOCKET; auth->fd = fd; SetAuthConnect(auth); if (result == IO_SUCCESS) send_auth_query(auth); /* this does a SetAuthPending(auth) for us */ return 1; }
/* * auth_dns_callback - called when resolver query finishes * if the query resulted in a successful search, hp will contain * a non-null pointer, otherwise hp will be null. * set the client on it's way to a connection completion, regardless * of success of failure */ static void auth_dns_callback(void* vptr, struct DNSReply* reply) { struct AuthRequest* auth = (struct AuthRequest*) vptr; assert(0 != auth); /* * need to do this here so auth_kill_client doesn't * try have the resolver delete the query it's about * to delete anyways. --Bleep */ ClearDNSPending(auth); if (reply) { const struct hostent* hp = reply->hp; int i; assert(0 != hp); /* * Verify that the host to ip mapping is correct both ways and that * the ip#(s) for the socket is listed for the host. */ for (i = 0; hp->h_addr_list[i]; ++i) { if (0 == memcmp(hp->h_addr_list[i], &(cli_ip(auth->client)), sizeof(struct in_addr))) break; } if (!hp->h_addr_list[i]) { if (IsUserPort(auth->client)) sendheader(auth->client, REPORT_IP_MISMATCH); sendto_opmask_butone(0, SNO_IPMISMATCH, "IP# Mismatch: %s != %s[%s]", cli_sock_ip(auth->client), hp->h_name, ircd_ntoa(hp->h_addr_list[0])); if (feature_bool(FEAT_KILL_IPMISMATCH)) { auth_kill_client(auth); return; } } else if (!auth_verify_hostname(hp->h_name, HOSTLEN)) { if (IsUserPort(auth->client)) sendheader(auth->client, REPORT_INVAL_DNS); } else { ++reply->ref_count; cli_dns_reply(auth->client) = reply; ircd_strncpy(cli_sockhost(auth->client), hp->h_name, HOSTLEN); if (IsUserPort(auth->client)) sendheader(auth->client, REPORT_FIN_DNS); } } else { /* * this should have already been done by s_bsd.c in add_connection * * strcpy(auth->client->sockhost, auth->client->sock_ip); */ if (IsUserPort(auth->client)) sendheader(auth->client, REPORT_FAIL_DNS); } if (!IsDoingAuth(auth)) { release_auth_client(auth->client); unlink_auth_request(auth, &AuthIncompleteList); free_auth_request(auth); } }