Squashed 'third_party/lksctp-tools/' content from commit 200eca7f1
Change-Id: I8f7575513f114b205178cac5c6b3706f3d725cb5
git-subtree-dir: third_party/lksctp-tools
git-subtree-split: 200eca7f1419b1ae53958b51e8551f7e7f6cd467
diff --git a/src/apps/myftp.c b/src/apps/myftp.c
new file mode 100644
index 0000000..64fa3f2
--- /dev/null
+++ b/src/apps/myftp.c
@@ -0,0 +1,413 @@
+/* myftp - simple file transfer over sctp testing tool.
+ * Copyright (c) 2002 Intel Corp.
+ *
+ * This file is part of the LKSCTP kernel Implementation. This
+ * is a submission by Xingang Guo from the Intel Corporation while
+ * participating on the LKSCTP project.
+ *
+ * The SCTP implementation is free software;
+ * you can redistribute it and/or modify it under the terms of
+ * the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * The SCTP implementation is distributed in the hope that it
+ * will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ * ************************
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU CC; see the file COPYING. If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Please send any bug reports or fixes you make to the
+ * email address(es):
+ * lksctp developers <sctp-developers-list@cig.mot.com>
+ *
+ * Or submit a bug report through the following website:
+ * http://www.sf.net/projects/lksctp
+ *
+ * Written or modified by:
+ * Xingang Guo <xingang.guo@intel.com>
+ * Jon Grimm <jgrimm@us.ibm.com>
+ *
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define _GNU_SOURCE
+#include <getopt.h>
+#include <netdb.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+#include <netinet/in.h> /* for sockaddr_in */
+#include <errno.h>
+#include <netinet/sctp.h>
+
+#define BUFSIZE 1024
+static char buffer[BUFSIZE];
+#define DUMP_CORE { char *diediedie = 0; *diediedie = 0; }
+
+typedef enum { COMMAND_NONE, COMMAND_RECV, COMMAND_SEND } command_t;
+
+/* These are the global options. */
+#define MAX_NUM_HOST 5
+static char *local_host[MAX_NUM_HOST];
+static int num_local_host = 0;
+static int local_port = 4444;
+
+static int buffer_size = BUFSIZE;
+static char *remote_host = NULL;
+static int remote_port = 4444;
+static command_t command = COMMAND_NONE;
+static char *filename = NULL;
+static int interactive = 0;
+static unsigned long delay = 0;
+static int verbose = 0;
+
+static void
+usage(char *argv0)
+{
+ fprintf(stderr, "Usage: %s [options]\n",argv0);
+ fprintf(stderr, "Options:\n");
+ fprintf(stderr, "\t--local, -H <hostname> Specify local interface\n");
+ fprintf(stderr, "\t--local-port, -P <port> Specify local port (default 4444)\n");
+ fprintf(stderr, "\t--remote, -h <hostname> Specify interface on remote host\n");
+ fprintf(stderr, "\t--remote-port, -p <port> Specify remote port (default 4444)\n");
+ fprintf(stderr, "\t--listen, -l Work in receiving mode\n");
+ fprintf(stderr, "\t--send, -s Work in sending mode\n");
+ fprintf(stderr, "\t--file, -f <filename> File to read or write,\n");
+ fprintf(stderr, "\t--buffer, -b <size> Buffer size. (default 1024 bytes)\n");
+ fprintf(stderr, "\t by default use standard input/output.\n");
+ fprintf(stderr, "\t--quick, -q Send packets continueously,\n");
+ fprintf(stderr, "\t do not wait for <ENTER> key. Default wait.\n");
+ fprintf(stderr, "\t--delay, -d <usec> Delay between consecutive sends (see --quick)\n");
+ fprintf(stderr, "\t--verbose, -v In verbose mode, display the progress.\n");
+ fprintf(stderr, "\n\t--help, Print this message.\n\n");
+} /* usage() */
+
+static int parse_arguments(int argc, char *argv[])
+{
+ int option_index = 0;
+ int c;
+ static struct option long_options[] = {
+ {"local", 1, 0, 1},
+ {"local-port", 1, 0, 2},
+ {"remote", 1, 0, 3},
+ {"remote-port", 1, 0, 4},
+ {"file", 1, 0, 5},
+ {"delay", 1, 0, 6},
+ {"buffer", 1, 0, 7},
+ {"listen", 0, 0, 10},
+ {"send", 0, 0, 11},
+ {"quick", 0, 0, 12},
+ {"verbose", 0, 0, 13},
+ {"help", 0, 0, 99},
+ {0, 0, 0, 0}
+ };
+
+ /* Parse the arguments. */
+ while (1) {
+ c = getopt_long(argc, argv, "H:P:h:p:f:d:b:qlsv",long_options,&option_index);
+ if (c == -1) break;
+
+ switch (c) {
+ case 0:
+ printf ("option %s", long_options[option_index].name);
+ if (optarg) printf (" with arg %s", optarg);
+ printf ("\n");
+ break;
+ case 1: /* local host */
+ case 'H':
+ local_host[num_local_host++] = optarg;
+ break;
+ case 2: /* local port */
+ case 'P':
+ local_port = atoi(optarg);
+ break;
+ case 3: /* remote host */
+ case 'h':
+ remote_host = optarg;
+ break;
+ case 4: /* remote port */
+ case 'p':
+ remote_port = atoi(optarg);
+ break;
+ case 5:
+ case 'f':
+ filename = optarg;
+ break;
+
+ case 6:
+ case 'd':
+ delay = strtoul(optarg,NULL,10);
+ printf("delay is %ld usec\n",delay);
+ break;
+
+ case 7:
+ case 'b':
+ buffer_size = atoi(optarg);
+ if ( buffer_size > BUFSIZE ) {
+ buffer_size = BUFSIZE;
+ fprintf(stderr,"Warning, buffer size too large, set to %d\n",buffer_size);
+ }
+ break;
+
+ case 12:
+ case 'q': interactive = 0; break;
+
+ case 13:
+ case 'v': verbose = 1; break;
+ /* COMMANDS */
+ case 10: /* listen */
+ case 'l':
+ if (command) {
+ fprintf(stderr, "%s: pick ONE of listen or send\n", argv[0]);
+ return 1;
+ }
+ else command = COMMAND_RECV;
+ break;
+
+ case 11: /* send */
+ case 's':
+ if (command) {
+ fprintf(stderr, "%s: pick ONE of listen or send\n", argv[0]);
+ return 2;
+ } else command = COMMAND_SEND;
+ break;
+
+ case '?':
+ case 99:
+ usage(argv[0]);
+ return 3;
+ break;
+
+ default:
+ printf ("%s: unrecognized option 0%c\n", argv[0], c);
+ usage(argv[0]);
+ return 4;
+ }
+ }
+
+ if (optind < argc) {
+ fprintf(stderr, "%s: non-option arguments are illegal: ", argv[0]);
+ while (optind < argc) fprintf(stderr, "%s ", argv[optind++]);
+ fprintf(stderr, "\n");
+ usage(argv[0]);
+ return 5;
+ }
+
+
+ if (0 == num_local_host) {
+ fprintf(stderr, "%s: You MUST provide a local host.\n", argv[0]);
+ usage(argv[0]);
+ return 6;
+ }
+
+ if ( filename == NULL && command == COMMAND_SEND)
+ fprintf(stderr,"%s: Use standard input to send\n",argv[0]);
+
+ if ( filename == NULL && command == COMMAND_RECV )
+ fprintf(stderr,"%s: Use standard output to write\n",argv[0]);
+
+ return 0;
+} /* parse_arguments() */
+
+static void
+emsg(char *prog,char *s)
+{
+ if ( prog != NULL ) fprintf(stderr,"%s: ",prog);
+ perror(s);
+ fflush(stdout);
+ //DUMP_CORE;
+
+ exit(-1);
+}
+
+static int build_endpoint(char *argv0)
+{
+ int retval,i;
+
+ /* Create the local endpoint. */
+ if ( (retval = socket(PF_INET, SOCK_SEQPACKET, IPPROTO_SCTP)) < 0 ) {
+ emsg(argv0,"socket");
+ exit(retval);
+ }
+
+ for ( i = 0;i < num_local_host;i++ ) {
+ struct hostent *hst;
+ struct sockaddr_in laddr;
+
+ memset(&laddr, 0, sizeof(laddr));
+ /* Get the transport address for the local host name. */
+ fprintf(stderr,"Hostname %d is %s\n",i+1,local_host[i]);
+ if ( (hst = gethostbyname(local_host[i])) == NULL ) {
+ fprintf(stderr, "%s: bad hostname: %s\n", argv0, local_host[i]);
+ exit(1);
+ }
+ memcpy(&laddr.sin_addr, hst->h_addr_list[0],sizeof(laddr.sin_addr));
+ laddr.sin_port = htons(local_port);
+ laddr.sin_family = AF_INET;
+
+ /* Bind this socket to the test port. */
+ if ( bind(retval, (struct sockaddr *)&laddr, sizeof(laddr)) ) {
+ emsg(argv0,"bind");
+ exit(-1);
+ }
+ }
+
+ fprintf(stderr,"Endpoint built.\n");
+
+ return retval;
+} /* build_endpoint() */
+
+/* Convenience structure to determine space needed for cmsg. */
+typedef union {
+ struct sctp_initmsg init;
+ struct sctp_sndrcvinfo sndrcvinfo;
+} _sctp_cmsg_data_t;
+
+
+/* Listen on the socket, printing out anything that arrives. */
+static void
+command_recv(char *argv0, int sk)
+{
+ struct msghdr inmessage;
+ char incmsg[CMSG_SPACE(sizeof(_sctp_cmsg_data_t))];
+ struct iovec iov;
+ int ret;
+ int fd;
+ int ct;
+
+ if (listen(sk, 1) == -1)
+ emsg(argv0, "listen");
+ /* Initialize inmessage with enough space for DATA... */
+ memset(&inmessage, 0, sizeof(inmessage));
+ iov.iov_base = buffer;
+ iov.iov_len = buffer_size;
+ inmessage.msg_iov = &iov;
+ inmessage.msg_iovlen = 1;
+ /* or a control message. */
+ inmessage.msg_control = incmsg;
+ inmessage.msg_controllen = sizeof(incmsg);
+
+ /* creat a file */
+ if ( filename == NULL ) fd = 1;
+ else if ( (fd = open(filename,O_WRONLY|O_CREAT|O_TRUNC,S_IREAD|S_IWRITE)) == -1 )
+ emsg(argv0,"open");
+
+ fprintf(stderr,"%s Receiving...\n", argv0);
+ /* Get the messages sent */
+ ct = 0;
+ while ( (ret = recvmsg(sk, &inmessage, MSG_WAITALL)) >= 0 ) {
+ if ( verbose )
+ fprintf(stderr,"%s-%d received %d bytes\n",
+ argv0, ++ct, ret);
+ if ( !(inmessage.msg_flags & MSG_NOTIFICATION) ) {
+ //printf("%s write %d bytes\n",argv0,ret);
+ if ( write(fd,buffer,ret) != ret ) emsg(argv0,"write");
+ } else {
+ union sctp_notification *sn;
+ sn = (union sctp_notification *)iov.iov_base;
+ if ((sn->sn_header.sn_type == SCTP_ASSOC_CHANGE) &&
+ (sn->sn_assoc_change.sac_state
+ == SCTP_SHUTDOWN_COMP))
+ break;
+ }
+
+ }
+
+ if ( ret < 0 ) emsg(argv0,"recvmsg");
+
+ close(fd);
+ close(sk);
+} /* command_recv() */
+
+/* Read lines from stdin and send them to the socket. */
+static void
+command_send(char *argv0, int sk)
+{
+ struct msghdr outmsg;
+ struct iovec iov;
+ struct hostent *hst;
+ struct sockaddr_in remote_addr;
+ int fd;
+ int msglen;
+ int ct;
+
+ /* Set up the destination. */
+ hst = gethostbyname(remote_host);
+ if (hst == NULL || hst->h_length < 1) {
+ fprintf(stderr, "%s: bad hostname: %s\n", argv0, remote_host);
+ exit(1);
+ }
+ memcpy(&remote_addr.sin_addr, hst->h_addr_list[0], sizeof(remote_addr.sin_addr));
+ remote_addr.sin_port = htons(remote_port);
+ remote_addr.sin_family = AF_INET;
+
+ /* Initialize the message struct we use to pass messages to
+ * the remote socket.
+ */
+ iov.iov_base = buffer;
+ iov.iov_len = buffer_size;
+ outmsg.msg_iov = &iov;
+ outmsg.msg_iovlen = 1;
+ outmsg.msg_control = NULL;
+ outmsg.msg_controllen = 0;
+ outmsg.msg_name = &remote_addr;
+ outmsg.msg_namelen = sizeof(remote_addr);
+
+ /* open the file */
+ if ( filename == NULL ) fd = 0;
+ else if ( (fd = open(filename,O_RDONLY)) == -1 ) emsg(argv0,"open");
+
+ fprintf(stderr,"%s ready to send...\n", argv0);
+ ct = 0;
+ while ( (msglen = read(fd,buffer,buffer_size)) > 0 ) {
+ /* Send to our neighbor. */
+ iov.iov_len = msglen;
+ if ( sendmsg(sk, &outmsg, 0) != msglen ) emsg(argv0,"sendmsg");
+ if ( verbose ) fprintf(stderr,"%s-%d send %d bytes\n",argv0,++ct,msglen);
+ if ( interactive && fd != 1 )
+ getchar();
+ // no flow control? no problem, make it slow
+ else if ( delay > 0 )
+ usleep(delay);
+ }
+
+ close(fd);
+ close(sk);
+} /* command_send() */
+
+int main(int argc, char *argv[])
+{
+ int ret;
+
+ if (( ret = parse_arguments(argc, argv) )) return ret;
+
+ switch(command) {
+ case COMMAND_NONE:
+ fprintf(stderr, "%s: Please specify a command.\n", argv[0]);
+ break;
+ case COMMAND_RECV:
+ command_recv(argv[0],build_endpoint(argv[0]));
+ break;
+ case COMMAND_SEND:
+ command_send(argv[0],build_endpoint(argv[0]));
+ break;
+ default:
+ fprintf(stderr, "%s: illegal command %d\n", argv[0], command);
+ } /* switch(command) */
+
+ return 0;
+}