SOCKET skt_connect(skt_ip_t ip, int port, int timeout)
{
struct sockaddr_in addr=skt_build_addr(ip,port);
int ok, begin;
SOCKET ret;
begin = time(0);
while (time(0)-begin < timeout)
{
ret = socket(AF_INET, SOCK_STREAM, 0);
if (ret==SOCKET_ERROR)
{
if (skt_should_retry()) continue;
else return skt_abort(93512,"Error creating socket");
}
ok = connect(ret, (struct sockaddr *)&(addr), sizeof(addr));
if (ok != SOCKET_ERROR)
return ret;/*Good connect*/
else { /*Bad connect*/
skt_close(ret);
if (skt_should_retry()) continue;
else return skt_abort(93515,"Error connecting to socket\n");
}
}
/*Timeout*/
return skt_abort(93517,"Timeout in socket connect\n");
}
/*Send a Ccs reply down the given socket.
Closes the socket afterwards.
A CcsImplHeader len field equal to 0 means do not send any reply.
*/
void CcsServer_sendReply(CcsImplHeader *hdr,int repBytes,const void *repData)
{
int fd=ChMessageInt(hdr->replyFd);
skt_abortFn old;
if (ChMessageInt(hdr->len)==0) {
CCSDBG(("CCS Closing reply socket without a reply.\n"));
skt_close(fd);
return;
}
old=skt_set_abort(reply_abortFn);
CCSDBG(("CCS Sending %d bytes of reply data\n",repBytes));
CcsServer_writeReply(fd,security,&hdr->attr,repBytes,(char *)repData);
skt_close(fd);
CCSDBG(("CCS Reply socket closed.\n"));
skt_set_abort(old);
}
/***********************************************
Send the given data as a CCS reply on the given socket.
Goes to some effort to minimize the number of "sends"
(and hence outgoing TCP packets) by assembling the
header and data in-place.
*/
static void CcsServer_writeReply(SOCKET fd,
CcsSecMan *security,
CcsSecAttr *attr,
int replyLen,char *reply)
{
const void *bufs[3]; int lens[3]; int nBuffers=0;
struct { /*Authentication header*/
SHA1_hash_t hash;
} aheader;
struct { /*Reply header*/
ChMessageInt_t len;
} header;
if (attr->auth==1)
{ /*Compose a reply SHA-1 hash header*/
CCS_AUTH_hash(security->getKey(security,attr),
ChMessageInt(attr->replySalt),NULL,&aheader.hash);
bufs[nBuffers]=&aheader; lens[nBuffers]=sizeof(aheader); nBuffers++;
}
/*Compose a simple reply header*/
header.len=ChMessageInt_new(replyLen);
bufs[nBuffers]=&header; lens[nBuffers]=sizeof(header); nBuffers++;
bufs[nBuffers]=reply; lens[nBuffers]=replyLen; nBuffers++;
if (-1==skt_sendV(fd,nBuffers,bufs,lens)) return;
skt_close(fd);
#undef n
}
int CcsServer_recvRequest(CcsImplHeader *hdr,void **reqData)
{
char ip_str[200];
skt_ip_t ip;
unsigned int port,ret=1;
SOCKET fd;
skt_abortFn old=skt_set_abort(req_abortFn);
CCSDBG(("CCS Receiving connection...\n"));
fd=skt_accept(ccs_server_fd,&ip,&port);
CCSDBG(("CCS Connected to IP=%s, port=%d...\n",skt_print_ip(ip_str,ip),port));
hdr->attr.ip=ip;
hdr->attr.port=ChMessageInt_new(port);
if (0==CcsServer_recvRequestData(fd,hdr,reqData))
{
fprintf(stdout,"During CCS Client IP:port (%s:%d) processing.\n",
skt_print_ip(ip_str,ip),
port);
skt_close(fd);
ret=0;
}
CCSDBG(("CCS Got all %d data bytes for request.\n",reqBytes));
skt_set_abort(old);
return ret;
}
SOCKET skt_connect(skt_ip_t ip, int port, int timeout)
{
struct sockaddr_in addr=skt_build_addr(ip,port);
int ok, begin;
SOCKET ret;
begin = time(0);
while (time(0)-begin < timeout)
{
ret = socket(AF_INET, SOCK_STREAM, 0);
if (ret==SOCKET_ERROR)
{
if (skt_should_retry()) continue;
else return skt_abort(-1, 93512, "Error creating socket");
}
ok = connect(ret, (struct sockaddr *)&(addr), sizeof(addr));
if (ok != SOCKET_ERROR)
return ret;/*Good connect*/
else { /*Bad connect*/
skt_close(ret);
if (skt_should_retry()) continue;
else {
#if ! defined(_WIN32) || defined(__CYGWIN__)
if (ERRNO == ETIMEDOUT) continue; /* time out is fine */
#endif
return skt_abort(-1, 93515, "Error connecting to socket\n");
}
}
}
/*Timeout*/
if (timeout==60)
return skt_abort(-1, 93517, "Timeout in socket connect\n");
return INVALID_SOCKET;
}
extern "C" void CcsImpl_kill(void)
{
skt_set_abort(noMoreErrors);
while (killList!=NULL)
{
SOCKET fd=skt_connect(killList->ip,killList->port,20);
if (fd!=INVALID_SOCKET) {
skt_sendN(fd,"die\n",strlen("die\n")+1);
skt_close(fd);
}
killList=killList->next;
}
}
// Main network access function:
void handle_client(SOCKET s, bool intranet) {
std::string status="Server ";
status+=get_address(&status);
status+=": ";
if (working_OK) status+="TOTALLY OK";
else status+="not really ok";
status+=", hackability=";
if (is_hackable) status+="high";
else status+="not so much";
status+=". Your name?\n";
skt_sendN(s,&status[0],status.size());
std::string name=skt_recv_line(s);
if (is_hackable && intranet) {
old_say_hello(&name[0]);
} else {
std::cout<<"Hello, "<<name<<"\n";
}
skt_close(s);
}
// Connection destructor
TCPConnection::~TCPConnection(){
std::cout << "closing socket: " << _socket << "\n";
_dead = true;
skt_close(_socket);
}
unsigned char *download_url(const char *url_in, int verbose, int *length)
{
char *url=STRDUP(url_in);
// parse the url
char *protocol, *host, *path;
int port;
parse_url(url, &protocol, &host, &port, &path);
if (verbose)
printf("Connecting to URL: %s://%s:%d%s\n", protocol, host, port, path);
int timeout = 60;
if (verbose)
printf("Looking up IP Address for: %s\n", host);
skt_ip_t hostIP = skt_lookup_ip(host);
if (verbose)
printf("Connecting to %s\n", host);
SOCKET s = skt_connect(hostIP, port, timeout);
char *send_get = MALLOC(strlen(url)+128);
sprintf(send_get,
"GET %s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-Agent: Mozilla/5.0\r\n"
"\r\n", path, host);
// send our get request
skt_sendN(s, send_get, strlen(send_get));
// wait...
if (verbose)
printf("Waiting for a response from %s\n", host);
char *status = skt_recv_line(s);
if (verbose)
printf("Received status: %s\n", status);
//char *status_trim = trim_spaces(status);
free(status);
// now can get the response code
//int code = atoi(status_trim);
//free(status_trim);
// a zero-length line indicates the end of the HTTP headers... we ignore
int len=-1;
while (1) {
char *line = skt_recv_line(s);
if (strlen(line)==0) break;
if (strstr(line, "Content-Length") != 0) {
char *l = line + strlen("Content-Length") + 2;
len=atoi(l);
}
}
if (verbose)
printf("Content Length: %d\n", len);
if (len==-1) {
asfPrintWarning("No Content-Length specified in the HTTP headers.\n");
return NULL;
}
// receiving data...
unsigned char *data = CALLOC(len+12, sizeof(char));
int curr=0, chunkSize=1024;
while (1) {
int amt = chunkSize < len-curr ? chunkSize : len-curr;
skt_recvN(s,data+curr,amt);
curr += amt;
if (verbose)
printf("Retrieved %d Kb so far.\n", curr);
if (curr==len)
break;
else if (curr>len)
asfPrintError("Invalid Content-Length?\n");
}
if(verbose)
printf("Done.\n");
//if (verbose)
// printf("Received data:\n"
// "-------------------------------------------------------------\n"
// "%s\n"
// "-------------------------------------------------------------\n",
// data);
free(protocol);
free(host);
free(path);
free(url);
free(send_get);
skt_close(s);
*length = len;
return data;
}
static void udp_close(struct protocol_ctx *sc)
{
struct udp_ctx *c = sc->priv;
return skt_close(c->fd);
}
void ctrl_c_op(int signo)
{
skt_close(_rpcd->listen_fd);
exit(0);
}
