static int test_md5_basic(void)
{
const char md5_challenge[] = "thequickbrownfox";
const uint8_t md5_control[16] = { 0x30, 0x8f, 0xb7, 0x6d, 0xc4, 0xd7, 0x30, 0x36, 0x0e, 0xe3, 0x39, 0x32, 0xd2, 0xfb, 0x10, 0x56 };
const char md5_control_str[33] = "308fb76dc4d730360ee33932d2fb1056";
uint8_t md5_result[16] = { 0x00 };
char md5_result_str[33] = "";
digest_get((uint8_t *)md5_challenge, (unsigned int)strlen(md5_challenge), md5_result);
digest_to_str(md5_control, md5_result_str);
if (strcmp(md5_control_str, md5_result_str) != 0)
{
fprintf(stderr, "Error: digest_to_str mismatch. Expected 0x%s Got: 0x%s\n", md5_control_str, md5_result_str);
return -EINVAL;
}
digest_to_str(md5_result, md5_result_str);
if (strcmp(md5_control_str, md5_result_str) != 0)
{
fprintf(stderr, "Error: digest_get mismatch. Expected: 0x%s Got: 0x%s\n", md5_control_str, md5_result_str);
return -EINVAL;
}
return 0;
}
static int client(const char *filepath,
struct in_addr *srv_inetaddr, int port)
{
int sock, ret = EXIT_FAILURE;
union {
struct sockaddr_sv serval;
struct sockaddr_in inet;
struct sockaddr saddr;
} cliaddr, srvaddr;
socklen_t addrlen = 0;
unsigned char digest[SHA_DIGEST_LENGTH];
unsigned short srv_inetport = (unsigned short)port;
int family = AF_SERVAL;
memset(&cliaddr, 0, sizeof(cliaddr));
memset(&srvaddr, 0, sizeof(srvaddr));
if (srv_inetaddr) {
family = AF_INET;
cliaddr.inet.sin_family = family;
cliaddr.inet.sin_port = htons(6767);
srvaddr.inet.sin_family = family;
srvaddr.inet.sin_port = htons(srv_inetport);
memcpy(&srvaddr.inet.sin_addr, srv_inetaddr,
sizeof(*srv_inetaddr));
addrlen = sizeof(cliaddr.inet);
} else {
cliaddr.serval.sv_family = family;
cliaddr.serval.sv_srvid.s_sid32[0] = htonl(getpid());
srvaddr.serval.sv_family = AF_SERVAL;
memcpy(&srvaddr.serval.sv_srvid,
&server_srvid, sizeof(server_srvid));
addrlen = sizeof(cliaddr.serval);
/* srvaddr.sv_flags = SV_WANT_FAILOVER; */
}
sock = socket_sv(family, SOCK_STREAM, 0);
set_reuse_ok(sock);
if (family == AF_SERVAL) {
ret = bind_sv(sock, &cliaddr.saddr, addrlen);
if (ret < 0) {
fprintf(stderr, "error client binding socket: %s\n",
strerror_sv(errno));
goto out;
}
}
if (family == AF_INET) {
char buf[18];
printf("Connecting to service %s:%u\n",
inet_ntop(family, srv_inetaddr, buf, 18),
srv_inetport);
} else {
printf("Connecting to service id %s\n",
service_id_to_str(&srvaddr.serval.sv_srvid));
}
ret = connect_sv(sock, &srvaddr.saddr, addrlen);
if (ret < 0) {
fprintf(stderr, "ERROR connecting: %s\n",
strerror_sv(errno));
goto out;
}
#if defined(SERVAL_NATIVE)
{
struct {
struct sockaddr_sv sv;
struct sockaddr_in in;
} saddr;
socklen_t addrlen = sizeof(saddr.in);
char ipaddr[18];
memset(&saddr, 0, sizeof(saddr));
ret = getsockname(sock, (struct sockaddr *)&saddr, &addrlen);
if (ret == -1) {
fprintf(stderr, "Could not get sock name : %s\n",
strerror(errno));
} else {
printf("sock name is %s @ %s\n",
service_id_to_str(&saddr.sv.sv_srvid),
inet_ntop(AF_INET, &saddr.in.sin_addr,
ipaddr, 18));
}
memset(&saddr, 0, sizeof(saddr));
ret = getpeername(sock, (struct sockaddr *)&saddr, &addrlen);
if (ret == -1) {
fprintf(stderr, "Could not get peer name : %s\n",
strerror(errno));
} else {
printf("peer name is %s @ %s\n",
service_id_to_str(&saddr.sv.sv_srvid),
inet_ntop(AF_INET, &saddr.in.sin_addr,
ipaddr, 18));
}
}
#endif
printf("Connected successfully!\n");
ret = recv_file(sock, filepath, digest);
if (ret == EXIT_SUCCESS) {
printf("SHA1 digest is [%s]\n", digest_to_str(digest));
} else {
printf("Receive failed\n");
}
out:
fprintf(stderr, "Closing socket...\n");
close_sv(sock);
return ret;
}
static int server(const char *filepath,
size_t send_memory_buffer_size,
int family)
{
int sock;
int backlog = 8;
union {
struct sockaddr_sv serval;
struct sockaddr_in inet;
struct sockaddr saddr;
} cliaddr, srvaddr;
socklen_t addrlen = 0;
unsigned char digest[SHA_DIGEST_LENGTH];
int ret = EXIT_FAILURE;
unsigned short srv_inetport = 49254;
memset(&cliaddr, 0, sizeof(cliaddr));
memset(&srvaddr, 0, sizeof(srvaddr));
if (family == AF_INET) {
cliaddr.inet.sin_family = family;
srvaddr.inet.sin_family = family;
srvaddr.inet.sin_addr.s_addr = INADDR_ANY;
srvaddr.inet.sin_port = htons(srv_inetport);
addrlen = sizeof(srvaddr.inet);
} else {
cliaddr.serval.sv_family = family;
srvaddr.serval.sv_family = AF_SERVAL;
memcpy(&srvaddr.serval.sv_srvid,
&listen_srvid, sizeof(listen_srvid));
addrlen = sizeof(cliaddr.serval);
}
sock = socket_sv(family, SOCK_STREAM, 0);
if (sock < 0) {
fprintf(stderr, "error creating AF_SERVAL socket: %s\n",
strerror(errno));
return EXIT_FAILURE;
}
set_reuse_ok(sock);
ret = bind_sv(sock, &srvaddr.saddr, addrlen);
if (ret < 0) {
fprintf(stderr, "error binding socket: %s\n", strerror(errno));
close_sv(sock);
return ret;
}
if (family == AF_INET) {
printf("server: bound to port %u\n",
srv_inetport);
} else {
printf("server: bound to service id %s\n",
service_id_to_str(&listen_srvid));
}
ret = listen_sv(sock, backlog);
if (ret < 0) {
fprintf(stderr, "error setting listening socket: %s\n",
strerror(errno));
close_sv(sock);
return ret;
}
while (!should_exit) {
socklen_t l = addrlen;
int client_sock;
long offset = 0;
printf("Waiting for new connections\n");
client_sock = accept_sv(sock, &cliaddr.saddr, &l);
if (client_sock < 0) {
fprintf(stderr, "error accepting new conn: %s\n",
strerror_sv(errno));
continue;
}
if (family == AF_INET) {
char buf[18];
printf("Connect request from %s:%u\n",
inet_ntop(family,
&cliaddr.inet.sin_addr, buf, 18),
ntohs(cliaddr.inet.sin_port));
} else {
printf("Connect req from service id %s (sock = %d)\n",
service_id_to_str(&cliaddr.serval.sv_srvid),
client_sock);
}
if (send_memory_buffer_size > 0)
ret = send_memory_buffer(client_sock,
send_memory_buffer_size,
digest);
else
ret = send_file(client_sock, filepath, offset,
digest);
if (ret == EXIT_SUCCESS) {
printf("Send successful\n");
printf("SHA1 digest is [%s]\n", digest_to_str(digest));
} else if (ret < 0) {
fprintf(stderr, "Failed data transfer to client\n");
//should_exit = 1;
}
close_sv(client_sock);
}
close_sv(sock);
return ret;
}
