int
initiate_preregistration_mode (SA *sa)
{
int pos;
/*
* these algs should, ideally, come from the PF_KEY, and they should
* have some implied preference and logical construction. For now just
* stick 'em here in plain serial, logical OR.
*/
sa->hash_alg = HASH_SHA;
sa->encr_alg = ET_DES_CBC;
sa->auth_alg = PRESHRD;
sa->group_desc = 1; /* the default Oakley group */
/* Nike : We use the Aggressive mode */
construct_header(sa, NIKE_PREREGISTRATION, 0, ISA_SA);
pos = sizeof(isakmp_hdr);
construct_isakmp_sa(sa, ISA_KE, &pos);
construct_ke(sa, ISA_SIGREQ, &pos);
construct_sig_req(sa, 0, &pos);
#if 0
switch (sa->auth_alg)
{
case PRESHRD:
construct_id(sa, ISA_HASH, &pos);
construct_hash(sa, 0, &pos);
break;
default:
break;
}
#endif
return(0);
}
int main(int argc, char *argv[])
{
int fd, fdr;
struct sockaddr_in sa;
int msg_size;
char *msg;
int sleep_val;
if (argc != 5 && argc != 6) {
printf("Usage: %s <ip> <port> <msg size> <sleep_val> <opt:rcv_port>\n", argv[0]);
return -1;
}
sleep_val = atoi(argv[4]);
sleep_val = sleep_val == 0 ? 1 : sleep_val;
msg_size = atoi(argv[3]);
msg_size = msg_size < (sizeof(unsigned long long)*2) ? (sizeof(unsigned long long)*2) : msg_size;
msg = malloc(msg_size);
rcv_msg = malloc(msg_size);
sa.sin_family = AF_INET;
sa.sin_port = htons(atoi(argv[2]));
sa.sin_addr.s_addr = inet_addr(argv[1]);
if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
perror("Establishing socket");
return -1;
}
if (argc == 6) {
struct sockaddr_in si;
if ((fdr = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
perror("Establishing receive socket");
return -1;
}
/*if (socket_nonblock(fdr)) {
return -1;
}*/
memset(&si, 0, sizeof(si));
si.sin_family = AF_INET;
si.sin_port = htons(atoi(argv[5]));
si.sin_addr.s_addr = htonl(INADDR_ANY);
printf("Binding the receive socket to port %d\n", atoi(argv[5]));
if (bind(fdr, (struct sockaddr *)&si, sizeof(si))) {
perror("binding receive socket");
return -1;
}
rcv = 1;
}
start_timers();
while (1) {
int i;
construct_header(msg);
if (sendto(fd, msg, msg_size, 0, (struct sockaddr*)&sa, sizeof(sa)) < 0 &&
errno != EINTR) {
perror("sendto");
return -1;
}
msg_sent++;
for (i=0 ; i < sleep_val ; i++) {
if (argc == 6) {
do_recv_proc(fdr, msg_size);
}
foo++;
}
//nanosleep(&ts, NULL);
}
return 0;
}
int main(int argc, char *argv[])
{
struct sockaddr_in sa;
char *msg;
int sleep_val, i, msg_size;
if (argc != 6) {
printf("Usage: %s <ip> <port> <msg size> <sleep_val> <conns>\n", argv[0]);
return -1;
}
sleep_val = atoi(argv[4]);
sleep_val = sleep_val == 0 ? 1 : sleep_val;
msg_size = atoi(argv[3]);
msg_size = msg_size < (sizeof(unsigned long long)*2) ? (sizeof(unsigned long long)*2) : msg_size;
msg = malloc(msg_size);
rcv_msg = malloc(msg_size);
conns = atoi(argv[5]);
conn_fds = malloc(conns * sizeof(int));
if (!conn_fds || !msg || !rcv_msg) return -1;
sa.sin_family = AF_INET;
sa.sin_port = htons(atoi(argv[2]));
sa.sin_addr.s_addr = inet_addr(argv[1]);
for (i = 0 ; i < conns ; i++) {
if ((conn_fds[i] = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
perror("Establishing socket");
fflush(stdout);
return -1;
}
if (socket_nonblock(conn_fds[i])) return -1;
if (connect(conn_fds[i], (struct sockaddr*)&sa, sizeof(sa)) &&
errno != EINPROGRESS) {
perror("connecting");
return -1;
}
}
printf("Start communication\n");
fflush(stdout);
start_timers();
while (1) {
int i, j;
construct_header(msg);
for (i = 0 ; i < conns ; i++) {
if (write(conn_fds[i], msg, msg_size) < 0 &&
errno != EINTR && errno != EAGAIN) {
perror("sendto");
fflush(stdout);
return -1;
}
if (errno != EINTR || errno != EAGAIN) {
msg_sent++;
}
for (j = 0 ; j < sleep_val ; j++) {
do_recv_proc(conn_fds[i], msg_size);
}
}
//nanosleep(&ts, NULL);
}
return 0;
}
int main()
{
struct sockaddr_in server;
int ret;
uint8_t buff[1024];
uint8_t *pb;
size_t len;
signal(SIGSEGV, handler);
signal(SIGINT, ihandler);
bzero(&server, sizeof(struct sockaddr_in));
server.sin_family = AF_INET;
server.sin_port = htons(2811);
server.sin_addr.s_addr = htonl(INADDR_ANY);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (bind(sockfd, (struct sockaddr *)&server, sizeof(struct sockaddr_in)) < 0) {
printf("[%s] Bind failed\n",__func__);
close(sockfd);
exit(1);
}
if(listen(sockfd, 500) < 0) {
printf("[%s] Listen failed\n",__func__);
close(sockfd);
exit(1);
}
connfd = accept(sockfd, NULL, NULL);
ret = 0;
while( (ret += recv(connfd, buff, 1024, 0)) > 0)
{
if (ret == 45)
break;
}
printf("Emptied read buffer\n");
{
CTransferInfoResponseMsg msg = C_TRANSFER_INFO_RESPONSE_MSG__INIT;
CFileStats fs = C_FILE_STATS__INIT;
CListenInfo li = C_LISTEN_INFO__INIT;
fs.mode = C_FILE_STATS__FILE_OPEN_MODE__CREATE;
li.datainterfaceip = "192.168.1.15";
li.listenport = 8081;
msg.filestats = &fs;
msg.listentuple = &li;
msg.resumeinfo = NULL;
len = c_transfer_info_response_msg__get_packed_size(&msg);
pb = (uint8_t *)malloc(len+8);
construct_header(pb, TRANSFER_INFO_RESP, len);
c_transfer_info_response_msg__pack(&msg, pb + 8);
ret = send(connfd, pb, len + 8, 0);
printf("Sent %d bytes len:%d\n", ret, (int)len);
}
{
struct timeval tv;
CBeginRespMsg msg = C_BEGIN_RESP_MSG__INIT;
CTimeStamp ts = C_TIME_STAMP__INIT;
msg.begintime = &ts;
gettimeofday(&tv, NULL);
ts.secs = tv.tv_sec;
ts.usecs = tv.tv_usec;
len = c_begin_resp_msg__get_packed_size(&msg);
pb = (uint8_t *)malloc(len+8);
construct_header(pb, BEGIN_TRANSFER_RESP, len);
c_begin_resp_msg__pack(&msg, pb + 8);
ret = send(connfd, pb, len + 8, 0);
printf("Sent BEGIN_TRANSFER_RESP %d bytes len:%d\n", ret, (int)len);
}
#if 0
{
struct timeval tv;
CEndRespMsg msg = C_END_RESP_MSG__INIT;
CTimeStamp ts = C_TIME_STAMP__INIT;
msg.endtime = &ts;
msg.has_finalmd5sum = 0;
gettimeofday(&tv, NULL);
ts.secs = tv.tv_sec;
ts.usecs = tv.tv_usec;
len = c_end_resp_msg__get_packed_size(&msg);
pb = (uint8_t *)malloc(len+8);
construct_header(pb, END_TRANSFER_RESP, len);
c_end_resp_msg__pack(&msg, pb + 8);
ret = send(connfd, pb, len + 8, 0);
printf("Sent END_TRANSFER_RESP, %d bytes len:%d\n", ret, (int)len);
}
#endif
{
RespMsg msg = RESP_MSG__INIT;
msg.respcode = 1;
msg.errstr = "Unable to create file on server\n";
len = resp_msg__get_packed_size(&msg);
pb = (uint8_t *)malloc(len+8);
construct_header(pb, COMMON_ERR_RESP, len);
resp_msg__pack(&msg, pb+8);
ret = send(connfd, pb, len + 8, 0);
printf("Sent END_TRANSFER_RESP, %d bytes len:%d\n", ret, (int)len);
}
while(1);
return 0;
}
