TEST(XregisterName, NullName)
{
sockaddr_x sa;
Graph g(TEST_DAG);
g.fill_sockaddr(&sa);
EXPECT_EQ(-1, XregisterName(NULL, &sa));
}
TEST(XregisterName, EmptyName)
{
sockaddr_x sa;
Graph g(TEST_DAG);
g.fill_sockaddr(&sa);
EXPECT_EQ(-1, XregisterName("", &sa));
}
void echo_dgram()
{
int sock;
char buf[XIA_MAXBUF];
sockaddr_x cdag;
socklen_t dlen;
int n;
say("Datagram service started\n");
if ((sock = Xsocket(AF_XIA, SOCK_DGRAM, 0)) < 0)
die(-2, "unable to create the datagram socket\n");
struct addrinfo *ai;
if (Xgetaddrinfo(NULL, SID_DGRAM, NULL, &ai) != 0)
die(-1, "getaddrinfo failure!\n");
sockaddr_x *sa = (sockaddr_x*)ai->ai_addr;
Graph g((sockaddr_x*)ai->ai_addr);
printf("\nDatagram DAG\n%s\n", g.dag_string().c_str());
if (XregisterName(DGRAM_NAME, sa) < 0 )
die(-1, "error registering name: %s\n", DGRAM_NAME);
say("registered name: \n%s\n", DGRAM_NAME);
if (Xbind(sock, (sockaddr *)sa, sizeof(sa)) < 0) {
die(-3, "unable to bind to the dag\n");
}
pid_t pid = 0;
// only need to fork if doing stream echo at the same time
if (stream == 1)
pid = fork();
if (pid == 0) {
while (1) {
say("Dgram Server waiting\n");
dlen = sizeof(cdag);
memset(buf, 0, sizeof(buf));
if ((n = Xrecvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *)&cdag, &dlen)) < 0) {
warn("Recv error on socket %d, closing connection\n", pid);
break;
}
say("dgram received %d bytes\n", n);
if ((n = Xsendto(sock, buf, n, 0, (struct sockaddr *)&cdag, dlen)) < 0) {
warn("%5d send error\n", pid);
break;
}
say("dgram sent %d bytes\n", n);
}
Xclose(sock);
}
}
// XregisterName *************************************************************
// NOTE: these tests assume the DAG library generates valid sockaddr_x structures
// also, they don't check invalid XIDs and other bad input as the dag library
// should be handling that
TEST(XregisterName, ValidParameters)
{
sockaddr_x sa;
Graph g(TEST_DAG);
g.fill_sockaddr(&sa);
EXPECT_EQ(0, XregisterName(TEST_NAME, &sa));
}
//Just registering the service and openning the necessary sockets
int registerReceiver()
{
int sock;
say ("\n%s (%s): started\n", TITLE, VERSION);
// create a socket, and listen for incoming connections
if ((sock = Xsocket(AF_XIA, SOCK_STREAM, 0)) < 0)
die(-1, "Unable to create the listening socket\n");
// read the localhost AD and HID
if ( XreadLocalHostAddr(sock, myAD, sizeof(myAD), myHID, sizeof(myHID), my4ID, sizeof(my4ID)) < 0 )
die(-1, "Reading localhost address\n");
struct addrinfo *ai;
//FIXME: SID is hardcoded
if (Xgetaddrinfo(NULL, SID, NULL, &ai) != 0)
die(-1, "getaddrinfo failure!\n");
sockaddr_x *dag = (sockaddr_x*)ai->ai_addr;
//FIXME NAME is hard coded
if (XregisterName(NAME, dag) < 0 )
die(-1, "error registering name: %s\n", NAME);
if (Xbind(sock, (struct sockaddr*)dag, sizeof(dag)) < 0) {
Xclose(sock);
die(-1, "Unable to bind to the dag: %s\n", dag);
}
Graph g(dag);
say("listening on dag: %s\n", g.dag_string().c_str());
return sock;
}
TEST(XregisterName, NoNodes)
{
sockaddr_x sa;
Graph g(TEST_DAG);
g.fill_sockaddr(&sa);
sa.sx_addr.s_count = 0;
EXPECT_EQ(-1, XregisterName(TEST_NAME, &sa));
}
TEST(XregisterName, BadFamily)
{
sockaddr_x sa;
Graph g(TEST_DAG);
g.fill_sockaddr(&sa);
sa.sx_family = AF_INET;
EXPECT_EQ(-1, XregisterName(TEST_NAME, &sa));
}
int main(int argc, char *argv[])
{
int sock, n, chunkSock, acceptSock;
size_t dlen;
char buf[1024],theirDAG[1024];
//char* reply="Got your message";
char reply[1024];
pid_t pid;
char myAD[1024];
char myHID[1024];
//Open socket
sock=Xsocket(XSOCK_DGRAM);
if (sock < 0) error("Opening socket");
// read the localhost AD and HID
if ( XreadLocalHostAddr(sock, myAD, sizeof(myAD), myHID, sizeof(myHID)) < 0 )
error("Reading localhost address");
// make the src DAG (the one the server listens on)
char * dag = (char*) malloc(snprintf(NULL, 0, "RE %s %s %s", myAD, myHID, SID0) + 1);
sprintf(dag, "RE %s %s %s", myAD, myHID, SID0);
//Register this service name to the name server
char * sname = (char*) malloc(snprintf(NULL, 0, "%s", SNAME) + 1);
sprintf(sname, "%s", SNAME);
if (XregisterName(sname, dag) < 0 )
error("name register");
//Bind to the DAG
Xbind(sock,dag);
while (1) {
//Receive packet
memset(&buf[0], 0, sizeof(buf));
dlen = sizeof(theirDAG);
n = Xrecvfrom(sock,buf,1024,0,theirDAG,&dlen);
//n = Xrecv(acceptSock,buf,1024,0);
if (n < 0)
error("recvfrom");
//printf("\nReceived a datagram from:%s len %d strlen %d\n",theirDAG, (int)dlen, (int)strlen(theirDAG));
write(1,buf,n);
memset(&reply[0], 0, sizeof(reply));
strcat (reply, "Got your message: ");
strcat (reply, buf);
//Reply to client
Xsendto(sock,reply,strlen(reply)+1,0,theirDAG,strlen(theirDAG));
//Xsend(acceptSock,reply,strlen(reply),0);
}
return 0;
}
virtual void SetUp() {
sockaddr_x sa;
int sock = Xsocket(AF_XIA, SOCK_STREAM, 0);
XreadLocalHostAddr(sock, ad, XID_LEN, hid, XID_LEN, fid, XID_LEN);
sprintf(fdag, FULL_DAG, ad, hid, SID);
Graph gf(fdag);
gf.fill_sockaddr(&sa);
XregisterName(FULL_NAME, &sa);
sprintf(hdag, HOST_DAG, ad, hid);
Graph gh(hdag);
gh.fill_sockaddr(&sa);
XregisterName(HOST_NAME, &sa);
Xclose(sock);
nad = new Node(ad);
nhid = new Node(hid);
nsid = new Node(SID);
ai = NULL;
}
TEST(XgetDAGbyName, ExtraLen)
{
sockaddr_x sa;
socklen_t len = sizeof(sa) + 10;
Graph g(TEST_DAG);
g.fill_sockaddr(&sa);
XregisterName(TEST_NAME, &sa);
memset(&sa, 0, sizeof(sa));
EXPECT_EQ(0, XgetDAGbyName(TEST_NAME, &sa, &len));
EXPECT_EQ(len, sizeof(sa));
Graph g1(&sa);
// TEST_DAG was in form of AD:... HID:... SID:...
EXPECT_EQ(3, g1.num_nodes());
}
void echo_stream()
{
int acceptor, sock;
if (signal(SIGCHLD, reaper) == SIG_ERR) {
die(-1, "unable to catch SIGCHLD");
}
say("Stream service started\n");
/* Prepare XSSL context and get SID (based on RSA key) */
XSSL_CTX *ctx = XSSL_CTX_new();
if (ctx == NULL) {
die(-5, "Unable to create new XSSL_CTX\n");
}
char *SID = SID_from_keypair(ctx->keypair);
/* Prepare listen socket, binding to generated SID */
if ((acceptor = Xsocket(AF_XIA, SOCK_STREAM, 0)) < 0)
die(-2, "unable to create the stream socket\n");
struct addrinfo *ai;
if (Xgetaddrinfo(NULL, SID, NULL, &ai) != 0)
die(-1, "getaddrinfo failure!\n");
Graph g((sockaddr_x*)ai->ai_addr);
sockaddr_x *sa = (sockaddr_x*)ai->ai_addr;
printf("\nStream DAG\n%s\n", g.dag_string().c_str());
if (XregisterName(STREAM_NAME, sa) < 0 )
die(-1, "error registering name: %s\n", STREAM_NAME);
say("registered name: \n%s\n", STREAM_NAME);
if (Xbind(acceptor, (struct sockaddr *)sa, sizeof(sockaddr_x)) < 0) {
die(-3, "unable to bind to the dag\n");
}
Xlisten(acceptor, 5);
while (1) {
say("Xsock %4d waiting for a new connection.\n", acceptor);
if ((sock = Xaccept(acceptor, NULL, 0)) < 0) {
warn("Xsock %d accept failure! error = %d\n", acceptor, errno);
// FIXME: should we die here instead or try and recover?
continue;
}
say ("Xsock %4d new session\n", sock);
pid_t pid = fork();
if (pid == -1) {
die(-1, "FORK FAILED\n");
} else if (pid == 0) {
process(sock, ctx);
exit(0);
} else {
// FIXME: we need to close the socket in the main process or the file
// descriptor limit will be hit. But if Xclose is called, the connection
// is torn down in click as well keeping the child process from using it.
// for now use a regular close to shut it here without affecting the child.
close(sock);
}
}
Xclose(acceptor);
XSSL_CTX_free(ctx);
free(SID);
}
TEST(XregisterName, NullSockaddr)
{
EXPECT_EQ(-1, XregisterName(TEST_NAME, NULL));
}
int main(int argc, char **argv)
{
int sock = -1;
int peer = -1;
struct addrinfo hints, *ai;
// FIXME: put signal handlers back into code once Xselect is working
// signal(SIGINT, handler);
// signal(SIGTERM, handler);
configure(argc, argv);
say("XIA firehose listening on %s\n", name);
// get our local AD/HID and append the SID to the resultant dag
memset(&hints, 0, sizeof(hints));
hints.ai_flags = XAI_XIDSERV;
int rc = Xgetaddrinfo(NULL, SID, &hints, &ai);
if (rc != 0)
die("%s\n", Xgai_strerror(rc));
sockaddr_x *sa = (sockaddr_x*)ai->ai_addr;
if ( XregisterName(NAME, sa) < 0)
die("Unable to register name %s\n", name);
if ((sock = Xsocket(AF_XIA, SOCK_STREAM, 0)) < 0)
die("Unable to create socket\n");
if (Xbind(sock, (struct sockaddr*)sa, sizeof(sockaddr_x)) < 0) {
Xclose(sock);
die("Unable to bind to DAG\n");
}
while (!timetodie) {
fd_set fds;
FD_ZERO(&fds);
FD_SET(sock, &fds);
struct timeval tv;
tv.tv_sec = 2;
tv.tv_usec = 0;
if ((rc = Xselect(sock + 1, &fds, NULL, NULL, &tv)) < 0) {
printf("select failed\n");
break;
} else if (rc == 0) {
// timed out, try again
continue;
} else if (!FD_ISSET(sock, &fds)) {
// this shouldn't happen!
printf("something is really wrong, exiting\n");
break;
}
peer = Xaccept(sock, NULL, NULL);
if (peer < 0) {
printf("Xaccept failed\n");
break;
}
say("peer connected...\n");
pid_t pid = fork();
if (pid == -1) {
printf("fork failed\n");
break;
}
else if (pid == 0) {
process(peer);
exit(0);
}
else {
// use regular close so we don't rip out the Xsocket state from under the child
close(peer);
}
}
say("firehose exiting\n");
Xclose(sock);
return 0;
}
int main()
{
int sock;
socklen_t len;
char buf[XIA_MAXBUF];
sockaddr_x client;
time_t now;
struct tm *t;
// create a datagram socket
if ((sock = Xsocket(AF_XIA, SOCK_DGRAM, 0)) < 0) {
printf("error: unable to create the listening socket.\n");
exit(1);
}
struct addrinfo *ai;
if (Xgetaddrinfo(NULL, SID0, NULL, &ai) != 0) {
printf("error: unable to create source dag.");
exit(1);
}
sockaddr_x *sa = (sockaddr_x*)ai->ai_addr;
//Register this service name to the name server
if (XregisterName(SNAME, sa) < 0) {
printf("error: unable to register name/dag combo");
exit(1);
}
// bind to the DAG
if (Xbind(sock, (struct sockaddr*)sa, sizeof(sockaddr_x)) < 0) {
Xclose(sock);
printf("error: unable to bind to %s\n", SNAME);
exit(1);
}
while (1) {
len = sizeof(client);
if (Xrecvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr*)&client, &len) < 0) {
printf("error receiving client request\n");
// assume it's ok, and just keep listening
continue;
}
// we don't care what the client said, so we'll just ignore it
now = time(NULL);
t = gmtime(&now);
strftime(buf, sizeof(buf), "%c %Z", t);
Graph g(&client);
printf("request from:\n%s\n", g.dag_string().c_str());
//Reply to client
if (Xsendto(sock, buf, strlen(buf) + 1, 0, (struct sockaddr*)&client, sizeof(client)) < 0)
printf("error sending time to the client\n");
}
Xclose(sock);
return 0;
}
void echo_stream()
{
int acceptor, sock;
char sid_string[strlen("SID:") + XIA_SHA_DIGEST_STR_LEN];
if (signal(SIGCHLD, reaper) == SIG_ERR) {
die(-1, "unable to catch SIGCHLD");
}
say("Stream service started\n");
if ((acceptor = Xsocket(AF_XIA, SOCK_STREAM, 0)) < 0)
die(-2, "unable to create the stream socket\n");
// Generate an SID to use
if(XmakeNewSID(sid_string, sizeof(sid_string))) {
die(-1, "Unable to create a temporary SID");
}
struct addrinfo hints, *ai;
bzero(&hints, sizeof(hints));
hints.ai_socktype = SOCK_STREAM;
hints.ai_family = AF_XIA;
if (Xgetaddrinfo(NULL, sid_string, &hints, &ai) != 0)
die(-1, "getaddrinfo failure!\n");
Graph g((sockaddr_x*)ai->ai_addr);
sockaddr_x *sa = (sockaddr_x*)ai->ai_addr;
printf("\nStream DAG\n%s\n", g.dag_string().c_str());
if (XregisterName(STREAM_NAME, sa) < 0 )
die(-1, "error registering name: %s\n", STREAM_NAME);
say("registered name: \n%s\n", STREAM_NAME);
if (Xbind(acceptor, (struct sockaddr *)sa, sizeof(sockaddr_x)) < 0) {
die(-3, "unable to bind to the dag\n");
}
Xlisten(acceptor, 5);
while (1) {
say("Xsock %4d waiting for a new connection.\n", acceptor);
sockaddr_x sa;
socklen_t sz = sizeof(sa);
if ((sock = Xaccept(acceptor, (sockaddr*)&sa, &sz)) < 0) {
warn("Xsock %d accept failure! error = %d\n", acceptor, errno);
// FIXME: should we die here instead or try and recover?
continue;
}
Graph g(&sa);
say ("Xsock %4d new session\n", sock);
say("peer:%s\n", g.dag_string().c_str());
pid_t pid = Xfork();
if (pid == -1) {
die(-1, "FORK FAILED\n");
} else if (pid == 0) {
// close the parent's listening socket
Xclose(acceptor);
process(sock);
exit(0);
} else {
// close the child's socket
Xclose(sock);
}
}
Xclose(acceptor);
}
