int main(int argc, const char *argv[])
{
int listenfd, connfd;
pid_t childpid;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
listenfd = socket_r(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(argv[1]);
servaddr.sin_port = htons(80);
//void bind_r(int listening_socket, const struct sockaddr *addr, socklen_t addrlen, void *arg);
bind_r(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr), (char *)argv[1]);
//void listen_r(int sockfd, int backlog, void *arg);
listen_r(listenfd, 10, (char *)argv[1]);
for(;;){
clilen = sizeof(cliaddr);
//int accept_r(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
connfd = accept_r(listenfd, (struct sockaddr *)&cliaddr, &clilen);
if((childpid = fork_r()) == 0){
close_r(listenfd);
str_echo(connfd);
exit(0);
}
}
close_r(connfd);
return 0;
}
void start_test(int role) {
int sk, pid;
int i = 0;
DEBUG_PRINT(DEBUG_NONE, "\nStarting tests...\n");
repeat_count = repeat;
DEBUG_PRINT(DEBUG_MIN, "\tsocket(SOCK_STREAM, IPPROTO_SCTP)");
if ((sk = socket(s_loc.ss_family, SOCK_STREAM, IPPROTO_SCTP)) < 0 ) {
fprintf(stderr, "\n\n\t\t*** socket: failed to create"
" socket: %s ***\n", strerror(errno));
exit(1);
}
DEBUG_PRINT(DEBUG_MIN, " -> sk=%d\n", sk);
bind_r(sk, &s_loc);
if (role == SERVER) {
listen_r(sk, 1);
accept_r(sk);
} else {
connect_r(sk, (struct sockaddr *)&s_rem, r_len);
}
if ((pid = fork()) == 0) {
settimerhandle();
printstatus(gsk);
while(1);
} else {
if (!debug_level) {
printf(" ");
}
for(i = 0; i < repeat_count; i++) {
if (role == SERVER) {
DEBUG_PRINT(DEBUG_NONE, "Server: Receiving packets.(%d/%d)\n",
i+1, repeat_count);
server(gsk);
} else {
DEBUG_PRINT(DEBUG_NONE, "Client: Sending packets.(%d/%d)\n",
i+1, repeat_count);
client(sk);
}
fflush(stdout);
}
if (role == SERVER) close_r(gsk);
close_r(sk);
}
} /* start_test() */
void printstatus(int sk) {
static int cwnd = 0;
static int count = 0;
struct sctp_status status;
socklen_t optlen;
FILE * fp;
const char *state_to_str[] = {
[SCTP_INACTIVE] = "INACTIVE",
[SCTP_PF] = "PF",
[SCTP_ACTIVE] = "ACTIVE",
[SCTP_UNCONFIRMED] = "UNCONFIRMED",
};
optlen = sizeof(struct sctp_status);
if(getsockopt(sk, IPPROTO_SCTP, SCTP_STATUS, &status, &optlen) < 0) {
fprintf(stderr, "Error getting status: %s.\n", strerror(errno));
exit(1);
}
if (statusfile != NULL) {
if (count == 0)
unlink(statusfile);
if((fp = fopen(statusfile, "a+")) == NULL) {
perror("fopen");
exit(1);
}
} else
fp = stdout;
if (count == 0)
fprintf(fp, "NO. ASSOC-ID STATE RWND UNACKDATA PENDDATA INSTRMS OUTSTRMS "
"FRAG-POINT SPINFO-STATE SPINFO-CWDN SPINFO-SRTT SPINFO-RTO SPINFO-MTU\n");
if (cwnd != status.sstat_primary.spinfo_cwnd) {
count++;
fprintf(fp, "%-3d %-8d %-17s %-8d %-9d %-8d %-7d %-8d %-10d %-12s %-11d %-11d %-10d %d\n", count,
status.sstat_assoc_id, get_sstat_state(status.sstat_state),
status.sstat_rwnd, status.sstat_unackdata, status.sstat_penddata,
status.sstat_instrms, status.sstat_outstrms, status.sstat_fragmentation_point,
state_to_str[status.sstat_primary.spinfo_state],
status.sstat_primary.spinfo_cwnd, status.sstat_primary.spinfo_srtt,
status.sstat_primary.spinfo_rto, status.sstat_primary.spinfo_mtu);
}
cwnd = status.sstat_primary.spinfo_cwnd;
fflush(fp);
if (fp != stdout)
fclose(fp);
if (status.sstat_primary.spinfo_state != SCTP_ACTIVE) {
close_r(sk);
exit(1);
}
}
void start_test(int role)
{
int sk;
int i = 0;
DEBUG_PRINT(DEBUG_NONE, "\nStarting tests...\n");
repeat_count = repeat;
if (MIXED == role) {
repeat_count = repeat_count * msg_cnt; /* Repeat per assoc. */
mixed_mode_test();
return;
}
sk = socket_r();
bind_r(sk, &s_loc);
/* Do we need to do bindx() to add any additional addresses? */
if (bindx_add_addrs)
bindx_r(sk, bindx_add_addrs, bindx_add_count,
SCTP_BINDX_ADD_ADDR);
if (role == SERVER) {
listen_r(sk, 100);
} else {
if (socket_type == SOCK_STREAM && connectx_count == 0)
connect_r(sk, (struct sockaddr *)&s_rem, r_len);
if (connectx_count != 0)
connectx_r(sk, connectx_addrs, connectx_count);
}
if (!debug_level) {
printf(" ");
}
for(i = 0; i < repeat_count; i++) {
if (role == SERVER) {
DEBUG_PRINT(DEBUG_NONE,
"Server: Receiving packets.\n");
server(sk);
} else {
DEBUG_PRINT(DEBUG_NONE,
"Client: Sending packets.(%d/%d)\n",
i+1, repeat_count);
client(sk);
}
fflush(stdout);
}
close_r(sk);
} /* start_test() */
void start_test(int role)
{
int sk;
int i = 0;
DEBUG_PRINT(DEBUG_NONE, "\nStarting tests...\n");
repeat_count = repeat;
if (MIXED == role) {
repeat_count = repeat_count * msg_cnt; /* Repeat per assoc. */
mixed_mode_test();
return;
}
sk = socket_r();
bind_r(sk, &s_loc);
if (role == SERVER) {
listen_r(sk, 100);
}
if (!debug_level) {
printf(" ");
}
for(i = 0; i < repeat_count; i++) {
if (role == SERVER) {
DEBUG_PRINT(DEBUG_NONE,
"Server: Receiving packets.\n");
server(sk);
} else {
DEBUG_PRINT(DEBUG_NONE,
"Client: Sending packets.(%d/%d)\n",
i+1, repeat_count);
client(sk);
}
fflush(stdout);
}
close_r(sk);
} /* start_test() */
int main(int argc, const char *argv[])
{
struct sockaddr_in server_addr;
char buf[MAXLINE];
int n, sock_fd;
if(argc != 2)
err_sys("Usage ./server server_addr msg");
//int socket_r(int domain, int type, int protocol);
sock_fd = socket_r(AF_INET, SOCK_STREAM, 0);
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
//int inet_pton(int af, const char *src, void *dst);
inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
server_addr.sin_port = htons(SERVER_PORT);
//void connect_r(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen, void *arg);
connect_r(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr), (void *)argv[1]);
//ssize_t write_r(int fd, const void *ptr, size_t nbytes);
fprintf(stdout, "\n");
while(fgets(buf, MAXLINE, stdin) != NULL){
if(write_r(sock_fd, buf, strlen(buf)) == -1)
err_ret("write_r error");
//supplemention
//ssize_t read_r(int fd, void *ptr, size_t nbytes);
n = read(sock_fd, buf, MAXLINE);
if(n == 0)
fprintf(stdout, "peer side(%s port %d) has been closed.\n", argv[1], ntohs(server_addr.sin_port));
else {
fprintf(stdout, "responsed from server:\n");
write_r(STDOUT_FILENO, buf, n);
//fprintf(stdout, "\n");
}
}
//void close_r(int fd);
close_r(sock_fd);
return 0;
}
int main(int argc, const char *argv[])
{
struct sockaddr_in server_addr, client_addr;
socklen_t client_addr_len;
int connection_sock, listen_sock;
char buf[MAXLINE];
char str[INET_ADDRSTRLEN];
int i,n;
char bindmsg[1024];
int optval = 1;
//struct sigaction {
//void (*sa_handler)(int);
//void (*sa_sigaction)(int, siginfo_t *, void *);
//sigset_t sa_mask;
//int sa_flags;
//void (*sa_restorer)(void);
//};
struct sigaction act, oact;
//void *memcpy(void *dest, const void *src, size_t n);
strcpy(bindmsg, argv[1]);
strcat(bindmsg, " prot 8000");
if(argc != 2)
err_sys("Usage ./server server_addr");
//int socket_r(int domain, int type, int protocol);
listen_sock = socket(AF_INET, SOCK_STREAM, 0);
//int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
setsockopt_r(listen_sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVER_PORT);
//int inet_pton(int af, const char *src, void *dst);
inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
//void bind_r(int listening_socket, const struct sockaddr *addr, socklen_t addrlen, void *arg);
bind_r(listen_sock, (struct sockaddr *)&server_addr, sizeof(server_addr), (void *)bindmsg);
//void listen_r(int sockfd, int backlog, void *arg);
listen_r(listen_sock, SERVER_BACKLOG, (void *)bindmsg);
//int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)
//siganl process
act.sa_flags = 0;
act.sa_handler = signal_handler;
sigemptyset(&act.sa_mask);
sigaction(SIGCHLD, &act, &oact);
fprintf(stdout, "accepting connections ...\n");
pid_t pid;
while(1){
client_addr_len = sizeof(client_addr);
//int accept_r(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
connection_sock = accept_r(listen_sock, (struct sockaddr *)&client_addr, &client_addr_len);
if(connection_sock < 0){
if(errno == EINTR)
continue;
err_ret("accept() failed");
}
pid = fork();
if(pid < 0)
err_sys("call to fork");
else if(pid == 0){
close_r(listen_sock);
//ssize_t read_r(int fd, void *ptr, size_t nbytes);
while(1){
n = read_r(connection_sock, buf, MAXLINE);
if(n == 0) {
fprintf(stdout, "peer side(%s port %d) has been closed.\n", inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str)), ntohs(client_addr.sin_port));
break;
}
fprintf(stdout, "reciveed from %s at port %d\n", inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str)), ntohs(client_addr.sin_port));
for (i = 0; i < n; i++)
{
buf[i] = toupper(buf[i]);
}
//ssize_t write_r(int fd, const void *ptr, size_t nbytes);
write_r(connection_sock, buf, n);
}
close_r(connection_sock);
exit(0);
} else {
close_r(connection_sock);
}
//void close_r(int fd);
//close_r(connection_sock);
}
return 0;
}
void pipe_t::close()
{
close_r();
close_w();
}
