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