int main(int argc, char** argv)
{
func_args args;
StartTCP();
args.argc = argc;
args.argv = argv;
InitCyaSSL();
echoclient_test(&args);
FreeCyaSSL();
return args.return_code;
}
int main(int argc, char** argv)
{
func_args args;
StartTCP();
args.argc = argc;
args.argv = argv;
InitCyaSSL();
#ifdef DEBUG_CYASSL
CyaSSL_Debugging_ON();
#endif
echoserver_test(&args);
FreeCyaSSL();
return args.return_code;
}
int Curl_cyassl_init(void)
{
InitCyaSSL();
return 1;
}
int YellHttp_ExecRequest(YellHttp_Ctx *ctx, char *url)
{
int retval;
int i=0;
int endi;
int hostnamei;
int porti = 0;
int recvlen;
int stop = 0;
int headerspos = 0;
int linenum = 0;
int pos=0, pos2 = 0;
char *hdrfield, *hdrval;
struct hostent *host;
struct sockaddr_in client_addr;
FILE *fhttpdump;
struct stat filestatus;
char modifiedsincedate[512];
char hdrstr[512];
int send_modifiedsince_hdr = 0;
int valid_domain_name;
unsigned long serverip;
char request_type[8];
unsigned int content_len;
int err;
char errbuffer[80];
if(url==NULL)return YELLHTTP_EINVAL;
memset(ctx->url, 0, 512);
strncpy(ctx->url, url, 511);
ctx->server_flags &= YELLHTTP_SRVFLAG_USRFLAGS;
if(strncmp(ctx->url, "https", 5)==0)
{
#ifdef ENABLESSL
ctx->SSL = 1;
#else
return YELLHTTP_ESSLDISABLED;
#endif
i+= 8;
}
else if(strncmp(ctx->url, "http", 4)==0)
{
ctx->SSL = 0;
i+= 7;
}
else
{
return YELLHTTP_EINVAL;
}
hostnamei = i;
memset(ctx->hostname, 0, 512);
while(ctx->url[i]!='/' && ctx->url[i]!=':' && i<strlen(ctx->url))i++;
if(i>255)return YELLHTTP_EINVAL;
strncpy(ctx->hostname, &ctx->url[hostnamei], i - hostnamei);
memset(ctx->uri, 0, 512);
memset(ctx->portstr, 0, 8);
ctx->port = 80;
if(ctx->SSL)ctx->port = 443;
if(ctx->url[i]==':')
{
i++;
memset(ctx->portstr, 0, 8);
while((ctx->url[i]>('0'-1) && ctx->url[i]<('9'+1)) && porti<8 && i<strlen(ctx->url))
{
ctx->portstr[porti] = ctx->url[i];
i++;
porti++;
}
sscanf(ctx->portstr, "%hd", &ctx->port);
}
strcpy(ctx->uri, &ctx->url[i]);
i = strlen(ctx->uri) - 1;
if(i==-1)
{
ctx->uri[0] = '/';
i = 0;
}
endi = i;
memset(ctx->filename, 0, 512);
while(ctx->uri[i]!='/' && i>0)
{
if(ctx->uri[i]=='?')endi = i - 1;
i--;
}
if(strcmp(&ctx->uri[i], "/")==0)
{
strncpy(ctx->filename, "index.html", 512);
}
else
{
i++;
strncpy(ctx->filename, &ctx->uri[i], (endi + 1) - i);
}
printf("Looking up %s...\n", ctx->hostname);
valid_domain_name = 0;
for(hostnamei=0; hostnamei<strlen(ctx->hostname); hostnamei++)
{
if(ctx->hostname[hostnamei]>='A' && ctx->hostname[hostnamei]<='z')
{
valid_domain_name = 1;
break;
}
}
if(valid_domain_name)
{
if((host = gethostbyname(ctx->hostname)) == NULL)
{
return YELLHTTP_EDNSRESOLV;
}
serverip = *((unsigned long *) host->h_addr_list[0]);
}
else
{
serverip = inet_addr(ctx->hostname);
}
client_addr.sin_family = AF_INET;
client_addr.sin_port = htons(ctx->port);
client_addr.sin_addr.s_addr = serverip;
ctx->sock_client = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if(ctx->sock_client<0)
{
if(ctx->sock_client == -1)
{
printf("Failed to create socket: %d\n", ctx->sock_client);
return YELLHTTP_ESOCK;
}
else
{
printf("socket() returned %d, ignoring...\n", ctx->sock_client);
}
}
printf("Connecting to %s...\n", ctx->hostname);
if((retval = connect(ctx->sock_client, (struct sockaddr *)&client_addr, sizeof(client_addr)))<0)
{
printf("Failed: %d\n", retval);
return YELLHTTP_ECONN;
}
#ifdef ENABLESSL
SSL_METHOD* method;
SSL_CTX* sslctx;
SSL* ssl;
if(ctx->SSL)
{
InitCyaSSL();
CyaSSL_Debugging_ON();
method = SSLv3_client_method();
if(method)sslctx = SSL_CTX_new(method);
if(sslctx)SSL_CTX_set_verify(sslctx, SSL_VERIFY_NONE, 0);
if(sslctx)ssl = SSL_new(sslctx);
if(ssl)SSL_set_fd(ssl, ctx->sock_client);
if(method==NULL || sslctx==NULL || ssl==NULL)
{
if(method==NULL)printf("Method init failure ");
if(method==NULL)printf("SSL ctx init failure ");
if(method==NULL)printf("SSL init failure ");
err = SSL_get_error(ssl, 0);
printf("sslerr = %d, %s\n", err, ERR_error_string(err, errbuffer));
shutdown(ctx->sock_client,0);
close(ctx->sock_client);
if(sslctx)SSL_CTX_free(sslctx);
if(ssl)SSL_free(ssl);
FreeCyaSSL();
return err;
}
printf("Connecting to %s with SSL...\n", ctx->hostname);
if(SSL_connect(ssl)!=SSL_SUCCESS)
{
err = SSL_get_error(ssl, 0);
printf("sslerr = %d, %s\n", err, ERR_error_string(err, errbuffer));
shutdown(ctx->sock_client,0);
close(ctx->sock_client);
SSL_CTX_free(sslctx);
SSL_free(ssl);
FreeCyaSSL();
return err;
}
}
#endif
if(stat(ctx->filename, &filestatus)==0 && !(ctx->server_flags & YELLHTTP_SRVFLAG_NOCACHE))
{
memset(modifiedsincedate, 0, 512);
memset(hdrstr, 0, 512);
YellHttp_GenDate(modifiedsincedate, filestatus.st_mtime, ctx);
sprintf(hdrstr, "If-Modified-Since: %s\r\n", modifiedsincedate);
send_modifiedsince_hdr = 1;
}
memset(request_type, 0, 8);
if(strlen(ctx->request_type)>0)
{
strncpy(request_type, ctx->request_type, 8);
if(strncmp(request_type, "HEAD", 4)==0)stop = 1;
}
else
{
strncpy(request_type, "GET", 8);
}
snprintf((char*)ctx->sendbuf, SENDBUFSZ, "%s %s HTTP/%s\r\nHost: %s\r\nUser-Agent: %s\r\nConnection: close\r\n", request_type, ctx->uri, ctx->httpversion, ctx->hostname, ctx->useragent);
if(send_modifiedsince_hdr)strncat((char*)ctx->sendbuf, hdrstr, SENDBUFSZ);
if(ctx->range_end!=0)
{
memset(hdrstr, 0, 512);
snprintf(hdrstr, 512, "Range: bytes=%d-%d\r\n", ctx->range_start, ctx->range_end);
strncat((char*)ctx->sendbuf, hdrstr, SENDBUFSZ);
}
if(ctx->authenticated)
{
#ifdef ENABLESSL
if(ctx->auth_type==1)YellHttp_GenDigestAuthHdr(ctx);
#endif
strncat((char*)ctx->sendbuf, ctx->authorization_header, SENDBUFSZ);
}
if(strncmp(ctx->request_type, "POST", 4)==0)
{
if(ctx->postdata && ctx->postdata>0)
{
snprintf(hdrstr, 512, "Content-Type: %s\r\nContent-Length: %d\r\n", ctx->content_type, ctx->postdata_length);
strncat((char*)ctx->sendbuf, hdrstr, SENDBUFSZ);
}
}
if(strlen(ctx->headers)>0)strncat((char*)ctx->sendbuf, ctx->headers, SENDBUFSZ);
strncat((char*)ctx->sendbuf, "\r\n", SENDBUFSZ);
printf("Sending request...\n");
if(!ctx->SSL)
{
YellHttp_SendData(ctx->sock_client, ctx->sendbuf, strlen((char*)ctx->sendbuf));
}
else
{
#ifdef ENABLESSL
SSL_write(ssl, ctx->sendbuf, strlen((char*)ctx->sendbuf));
#endif
}
if(strncmp(ctx->request_type, "POST", 4)==0)
{
printf("Sending POST data...\n");
if(ctx->postdata==NULL || ctx->postdata_length==0)
{
printf("Ctx->postdata is NULL, or postdata_length is zero.\n");
shutdown(ctx->sock_client,0);
close(ctx->sock_client);
SSL_CTX_free(sslctx);
SSL_free(ssl);
FreeCyaSSL();
return YELLHTTP_EINVAL;
}
if(!ctx->SSL)
{
YellHttp_SendData(ctx->sock_client, ctx->postdata, ctx->postdata_length);
}
else
{
#ifdef ENABLESSL
SSL_write(ssl, ctx->postdata, ctx->postdata_length);
#endif
}
}
hdrfield = (char*)malloc(512);
hdrval = (char*)malloc(512);
printf("Waiting for response...(Headers)\n");
fhttpdump = fopen("httpheaders", "wb");
if(fhttpdump==NULL)
{
#ifdef ENABLESSL
if(ctx->SSL)
{
SSL_CTX_free(sslctx);
SSL_free(ssl);
FreeCyaSSL();
}
#endif
shutdown(ctx->sock_client,0);
close(ctx->sock_client);
free(hdrfield);
free(hdrval);
return YELLHTTP_EFILE;
}
while(1)
{
if(!ctx->SSL)
{
recvlen = YellHttp_RecvData(ctx->sock_client, &ctx->recvbuf[headerspos], 1);
}
else
{
#ifdef ENABLESSL
recvlen = SSL_read(ssl, &ctx->recvbuf[headerspos], 1);
#endif
}
if(recvlen<=0)
{
stop = 1;
break;
}
fwrite(&ctx->recvbuf[headerspos], 1, 1, fhttpdump);
if(ctx->recvbuf[headerspos]==0x0a)
{
ctx->recvbuf[headerspos+1]=0;
if(strlen((char*)ctx->recvbuf)<3)
{
headerspos = 0;
break;
}
if(headerspos>4)
{
if(linenum==0)
{
sscanf((char*)&ctx->recvbuf[9], "%d", &ctx->http_status);
memcpy(ctx->httpversion, &ctx->recvbuf[5], 3);
printf("HTTP status: %d\n", ctx->http_status);
if(ctx->http_status==304)stop = 1;
if(ctx->http_status==401)
{
ctx->auth_requirederrors++;
}
else
{
ctx->auth_requirederrors = 0;
}
}
else
{
memset(hdrfield, 0, 512);
memset(hdrval, 0, 512);
pos = 0;
pos2 = 0;
while(ctx->recvbuf[pos]!=':' && ctx->recvbuf[pos]!=0x0d && pos2<255)
{
hdrfield[pos2] = ctx->recvbuf[pos];
pos++;
pos2++;
}
if(ctx->recvbuf[pos]==':')
{
pos+=2;
pos2 = 0;
while(ctx->recvbuf[pos]!=0x0d && pos2<255)
{
hdrval[pos2] = ctx->recvbuf[pos];
pos++;
pos2++;
}
}
for(i=0; i<32; i++)
{
if(headercb_array[i].cb==NULL)continue;
if(strcmp(headercb_array[i].hdrfield, hdrfield)==0)
{
headercb_array[i].cb((char*)ctx->recvbuf, hdrfield, hdrval, ctx, headercb_array[i].usrarg);
}
}
}
linenum++;
headerspos = 0;
continue;
}
}
headerspos++;
}
fclose(fhttpdump);
free(hdrfield);
free(hdrval);
if(!stop)
{
printf("Receiving content, filename %s ...\n", ctx->filename);
fhttpdump = fopen(ctx->filename, "wb");
content_len = ctx->content_length;
if(fhttpdump==NULL)
{
#ifdef ENABLESSL
if(ctx->SSL)
{
SSL_CTX_free(sslctx);
SSL_free(ssl);
FreeCyaSSL();
}
#endif
shutdown(ctx->sock_client,0);
close(ctx->sock_client);
return YELLHTTP_EFILE;
}
if(!ctx->SSL)
{
if(content_len)
{
while(content_len)
{
recvlen = YellHttp_RecvData(ctx->sock_client, ctx->recvbuf, RECVBUFSZ);
fwrite(ctx->recvbuf, 1, recvlen, fhttpdump);
content_len-= recvlen;
}
}
else
{
while((recvlen = YellHttp_RecvData(ctx->sock_client, ctx->recvbuf, RECVBUFSZ))!=0)
{
fwrite(ctx->recvbuf, 1, recvlen, fhttpdump);
}
}
}
else
{
#ifdef ENABLESSL
if(content_len)
{
while(content_len)
{
recvlen = SSL_read(ssl, ctx->recvbuf, RECVBUFSZ);
fwrite(ctx->recvbuf, 1, recvlen, fhttpdump);
content_len-= recvlen;
}
}
else
{
while((recvlen = SSL_read(ssl, ctx->recvbuf, RECVBUFSZ))!=0)
{
fwrite(ctx->recvbuf, 1, recvlen, fhttpdump);
}
}
#endif
}
fclose(fhttpdump);
}
#ifdef ENABLESSL
if(ctx->SSL)
{
SSL_CTX_free(sslctx);
SSL_free(ssl);
FreeCyaSSL();
}
#endif
shutdown(ctx->sock_client,0);
close(ctx->sock_client);
if((ctx->http_status>=301 && ctx->http_status<=303) && !(ctx->server_flags & YELLHTTP_SRVFLAG_DISABLEREDIR))
{
printf("Redirected: %s\n", ctx->redirecturl);
return YellHttp_ExecRequest(ctx, ctx->redirecturl);
}
if(ctx->http_status==401 && ctx->authenticated)
{
if(ctx->authenticated==1)
{
return YellHttp_ExecRequest(ctx, url);
}
}
if(ctx->http_status>=400)return -ctx->http_status;
if(ctx->authenticated)
{
ctx->auth_nc++;
}
return 0;
}
int main(int argc, char** argv)
{
func_args args;
func_args server_args;
tcp_ready ready;
THREAD_TYPE serverThread;
StartTCP();
args.argc = server_args.argc = argc;
args.argv = server_args.argv = argv;
/* CTaoCrypt test */
ctaocrypt_test(&args);
if (args.return_code != 0) return args.return_code;
/* Simple CyaSSL client server test */
InitCyaSSL();
InitTcpReady(&ready);
server_args.signal = &ready;
start_thread(server_test, &server_args, &serverThread);
wait_tcp_ready(&server_args);
client_test(&args);
if (args.return_code != 0) return args.return_code;
join_thread(serverThread);
if (server_args.return_code != 0) return server_args.return_code;
/* Echo input yaSSL client server test */
start_thread(echoserver_test, &server_args, &serverThread);
wait_tcp_ready(&server_args);
{
func_args echo_args;
char* myArgv[NUMARGS];
char argc0[32];
char argc1[32];
char argc2[32];
myArgv[0] = argc0;
myArgv[1] = argc1;
myArgv[2] = argc2;
echo_args.argc = NUMARGS;
echo_args.argv = myArgv;
strcpy(echo_args.argv[0], "echoclient");
strcpy(echo_args.argv[1], "input");
strcpy(echo_args.argv[2], "output");
remove("output");
/* make sure OK */
echoclient_test(&echo_args);
if (echo_args.return_code != 0) return echo_args.return_code;
#ifdef CYASSL_DTLS
wait_tcp_ready(&server_args);
#endif
/* send quit to echoserver */
echo_args.argc = 2;
strcpy(echo_args.argv[1], "quit");
echoclient_test(&echo_args);
if (echo_args.return_code != 0) return echo_args.return_code;
join_thread(serverThread);
if (server_args.return_code != 0) return server_args.return_code;
}
/* validate output equals input */
{
byte input[MD5_DIGEST_SIZE];
byte output[MD5_DIGEST_SIZE];
file_test("input", input);
file_test("output", output);
if (memcmp(input, output, sizeof(input)) != 0)
return -1;
}
FreeCyaSSL();
FreeTcpReady(&ready);
printf("\nAll tests passed!\n");
return 0;
}
