int main(int argc, char *argv[])
{
unsigned char buf[BUF_SIZE];
unsigned char newbuf[BUF_SIZE];
char addrstr[INET_ADDRSTRLEN];
int sd, newsd;
ssize_t n;
socklen_t len;
struct sockaddr_in sa;
if (argc != 2) {
fprintf(stderr, "Usage: %s key\n", argv[0]);
exit(1);
}
unsigned char key[KEY_SIZE];
memcpy(key, argv[1], 16);
memset(buf, 0, sizeof(buf));
/* Make sure a broken connection doesn't kill us */
signal(SIGPIPE, SIG_IGN);
/* Create TCP/IP socket, used as main chat channel */
if ((sd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}
fprintf(stderr, "Created TCP socket\n");
/* Bind to a well-known port */
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(TCP_PORT);
sa.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
perror("bind");
exit(1);
}
fprintf(stderr, "Bound TCP socket to port %d\n", TCP_PORT);
/* Listen for incoming connections */
if (listen(sd, TCP_BACKLOG) < 0) {
perror("listen");
exit(1);
}
/* Loop forever, accept()ing connections */
for (;;) {
fprintf(stderr, "Waiting for an incoming connection...\n");
/* Accept an incoming connection */
len = sizeof(struct sockaddr_in);
if ((newsd = accept(sd, (struct sockaddr *)&sa, &len)) < 0) {
perror("accept");
exit(1);
}
if (!inet_ntop(AF_INET, &sa.sin_addr, addrstr, sizeof(addrstr))) {
perror("could not format IP address");
exit(1);
}
fprintf(stderr, "Incoming connection from %s:%d\n",
addrstr, ntohs(sa.sin_port));
/* Initialize crypto device */
int cfd;
cfd = open("/dev/crypto", O_RDWR);
if (cfd < 0) {
perror("open(/dev/crypto)");
exit(1);
}
struct session_op sess;
struct crypt_op cryp;
memset(&sess, 0, sizeof(sess));
memset(&cryp, 0, sizeof(cryp));
/*
* Use random values for the encryption key,
* the initialization vector (IV), and the
* data to be encrypted
*/
unsigned char iv[BLOCK_SIZE]="asdfghjklzxcvbnm";
cryp.iv = iv;
sess.key = key;
/*
* Get crypto session for AES128
*/
sess.cipher = CRYPTO_AES_CBC;
sess.keylen = KEY_SIZE;
if (ioctl(cfd, CIOCGSESSION, &sess)) {
perror("ioctl(CIOCGSESSION)");
exit(1);
}
cryp.ses = sess.ses;
cryp.len = BUF_SIZE;
/* Start chating... */
for (;;) {
struct timeval timeout;
timeout.tv_sec = sec;
timeout.tv_usec = msec;
fd_set set;
FD_ZERO(&set);
FD_SET(newsd, &set);
FD_SET(STDIN_FILENO, &set);
int returned = select(newsd + 1, &set, NULL, NULL, &timeout);
if ( returned > 0 ){
if (FD_ISSET(newsd, &set)) {
n = read(newsd, buf, sizeof(buf));
if (n <= 0) {
if (n < 0)
perror("read from remote peer failed");
else
fprintf(stderr, "Peer went away\n");
break;
}
/*
* Decrypt data
*/
cryp.src = buf;
cryp.dst = newbuf;
cryp.len = BUF_SIZE;
cryp.op = COP_DECRYPT;
if (ioctl(cfd, CIOCCRYPT, &cryp)) {
perror("ioctl(CIOCCRYPT)");
exit(1);
}
printf("Client: %s", newbuf);
}
if (FD_ISSET(STDIN_FILENO, &set)) {
n = read(STDIN_FILENO, buf, sizeof(buf));
/*
* Encrypt data.in to data.encrypted
*/
cryp.ses = sess.ses;
cryp.src = buf;
cryp.dst = newbuf;
cryp.len = BUF_SIZE;
//change iv////////////////////////////////
cryp.op = COP_ENCRYPT;
if (ioctl(cfd, CIOCCRYPT, &cryp)) {
perror("ioctl(CIOCCRYPT)");
exit(1);
}
if (insist_write(newsd, newbuf, BUF_SIZE) != BUF_SIZE) {
perror("write to remote peer failed");
break;
}
}
}
else if ( returned < 0 ) {
perror("select failed!");
exit(1);
}
memset(buf, 0, sizeof(buf));
}
/* Make sure we don't leak open files */
if (close(newsd) < 0)
perror("close");
/* Finish crypto session */
if (ioctl(cfd, CIOCFSESSION, &sess.ses)) {
perror("ioctl(CIOCFSESSION)");
return 1;
}
if (close(cfd) < 0) {
perror("close(fd)");
return 1;
}
}
/* This will never happen */
return 1;
}
int main(int argc, char *argv[])
{
int sd, port;
ssize_t n;
char buf[100];
char *hostname;
struct hostent *hp;
struct sockaddr_in sa;
fd_set socks; /* Socket file descriptors we want to wake
up for, using select() */
if (argc != 3) {
fprintf(stderr, "Usage: %s hostname port\n", argv[0]);
exit(1);
}
hostname = argv[1];
port = atoi(argv[2]); /* Needs better error checking */
/* Create TCP/IP socket, used as main chat channel */
if ((sd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}
fprintf(stderr, "Created TCP socket\n");
/* Look up remote hostname on DNS */
if ( !(hp = gethostbyname(hostname))) {
printf("DNS lookup failed for host %s\n", hostname);
exit(1);
}
/* Connect to remote TCP port */
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
memcpy(&sa.sin_addr.s_addr, hp->h_addr, sizeof(struct in_addr));
fprintf(stderr, "Connecting to remote host... "); fflush(stderr);
if (connect(sd, (struct sockaddr *) &sa, sizeof(sa)) < 0) {
perror("connect");
exit(1);
}
fprintf(stderr, "Connected.\n");
/* Be careful with buffer overruns, ensure NUL-termination */
//strncpy(buf, HELLO_THERE, sizeof(buf));
//strncpy(buf, "First Message", sizeof(buf));
//buf[sizeof(buf) - 1] = '\0';
/* Say something to other side!!! */
/*if (insist_write(sd, buf, strlen(buf)) != strlen(buf)) {
perror("write");
exit(1);
}*/
//fprintf(stdout, "I said:\n%s\nRemote says:\n", buf);
//fflush(stdout);
//printf("Before shutDown\n");
/*
* Let the remote know we're not going to write anything else.
* Try removing the shutdown() call and see what happens.
*/
/*if (shutdown(sd, SHUT_WR) < 0) {
perror("shutdown");
exit(1);
}*/
printf("Remote fd: %d, Local fd: %d\n",sd , 0 );
printf("\n\nNew Session Started!!!\n\n\n");
/* Read answer and write it to standard output */
for (;;) {
//printf("\n~~~~~~~~~~~~~~~~~~~~Client in loop again!!!!!!!!\n");
FD_ZERO(&socks);
FD_SET(sd,&socks);
FD_SET(STDIN_FILENO,&socks);
fprintf(stdout, "me: ");
fflush(stdout);
int readsocks = select(sd+1, &socks, NULL, NULL, NULL);
/* select() returns the number of sockets that had
things going on with them -- i.e. they're readable. */
/* Once select() returns, the original fd_set has been
modified so it now reflects the state of why select()
woke up. i.e. If file descriptor 4 was originally in
the fd_set, and then it became readable, the fd_set
contains file descriptor 4 in it. */
if (readsocks < 0) {
perror("select");
exit(EXIT_FAILURE);
}
else{
/* handle remote input */
if (FD_ISSET(sd,&socks)){
//printf("Checking remote buffer\n");
n = read(sd, buf, sizeof(buf));
if (n <= 0) {
if (n < 0)
perror("read from remote peer failed");
else
fprintf(stderr, "\nPeer went away...\n");
break;
}
//toupper_buf(buf, n);
fprintf(stdout, "\nRemote: ");
fflush(stdout);
if (insist_write(STDOUT_FILENO, buf, n) != n) {
perror("write to local buff failed");
break;
}
}
else{ /* handle local-buffer */
//printf("Checking local buffer\n");
n = read(0, buf, sizeof(buf));
if (n <= 0) {
if (n < 0)
perror("read from localy failed");
else
fprintf(stderr, "I went away\n");
break;
}
//toupper_buf(buf, n);
if (insist_write(sd, buf, n) != n) {
perror("write to remote failed");
break;
}
//printf("message sent\n");
}
}
}
/* Make sure we don't leak open files */
if (close(sd) < 0)
perror("close");
fprintf(stderr, "\nDone.\n");
return 0;
}
int main(int argv, char ** argc)
{
int fd,cr;
cr = open("/dev/cryptodev0", O_RDWR);
if (cr < 0) {
perror("open(/dev/cryptodev0)");
return 1;
}
struct session_op sess;
struct crypt_op cryp;
memset(key,0,sizeof(key));
// fprintf(stdout,"Give the key\n");
// read(0,key,sizeof(key));
// fprintf(stdout,"Give the iv\n");
memset(iv,0,sizeof(iv));
// read(0,iv,sizeof(iv));
strcpy(key,"marios");
strcpy(iv,"123");
init(cr,&sess,key);
char addrstr[INET_ADDRSTRLEN];
int sd, newsd;
ssize_t n;
socklen_t len;
struct sockaddr_un un;
signal(SIGPIPE, SIG_IGN);
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}
unlink("encrypt.socket");
fprintf(stderr, "Created Unix socket\n");
memset(&un, 0, sizeof(un));
un.sun_family = AF_UNIX;
strcpy(un.sun_path,"encrypt.socket");
int size = offsetof(struct sockaddr_un,sun_path) + strlen(un.sun_path) ;
if (bind(fd, (struct sockaddr *)&un, size) < 0) {
perror("bind");
exit(1);
}
fprintf(stderr, "Bound unix socket\n");
if (listen(fd, TCP_BACKLOG) < 0) {
perror("listen");
exit(1);
}
printf("accepted connection\n");
if ((newsd = accept(fd, (struct sockaddr *)&un, &len)) < 0) {
perror("accept");
exit(1);
}
unsigned char buf[DATA_SIZE];
memset(buf,0,sizeof(buf));
for (;;) {
n = read(newsd, buf, sizeof(buf));
if (n <= 0) {
if (n < 0)
perror("read from remote peer failed");
else
fprintf(stderr, "Peer went away\n");
break;
}
test_crypto(cr,buf,n,&sess,&cryp);
if (insist_write(newsd, res, 256) != 256) {
perror("write to remote peer failed");
break;
}
memset(buf,0,sizeof(buf));
}
if (ioctl(cr, CIOCFSESSION, &sess.ses)) {
perror("ioctl(CIOCFSESSION)");
return 1;
}
if (close(newsd) < 0)
perror("close");
if (close(cr) < 0) {
perror("close(fd)");
return 1;
}
return 0;
}
void server(unsigned char * key) {
char addrstr[INET_ADDRSTRLEN];
socklen_t len;
int sd, yes = 1, sd_max, curr_sd, cfd, ret, newsd;
struct sockaddr_in sa;
struct client *clients = NULL, *ptr = NULL, *ptr2 = NULL;
ssize_t n;
fd_set readfds, master;
struct timeval tv;
struct session_op sess;
struct crypt_op cryp;
struct crypt_data data ;
/* Make sure a broken connection doesn't kill us */
signal(SIGPIPE, SIG_IGN);
/* Create TCP/IP socket, used as main chat channel */
if ((sd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}
fprintf(stderr, "Created TCP socket\n");
setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
/* Bind to a well-known port */
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(TCP_PORT);
sa.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
perror("bind");
exit(1);
}
fprintf(stderr, "Bound TCP socket to port %d\n", TCP_PORT);
/* Listen for incoming connections */
if (listen(sd, TCP_BACKLOG) < 0) {
perror("listen");
exit(1);
}
memset(&sess, 0, sizeof(sess));
memset(&cryp, 0, sizeof(cryp));
memset(data.in,'\0', BUF_SIZE);
memset(data.encin,'\0', BUF_SIZE);
memset(data.encout,'\0', BUF_SIZE);
memset(data.decrypted,'\0', BUF_SIZE);
cfd = open("/dev/cryptodev0", O_RDWR);
if (cfd < 0) {
perror("open(/dev/cryptodev0)");
exit(1);
}
if (fill_urandom_buf(data.iv, BLOCK_SIZE) < 0) {
perror("getting data from /dev/urandom\n");
exit(1);
}
/*
* Get crypto session for AES128
*/
sess.cipher = CRYPTO_AES_CBC;
sess.keylen = KEY_SIZE;
sess.key = key;
if (ioctl(cfd, CIOCGSESSION, &sess)) {
perror("ioctl(CIOCGSESSION)");
exit(1);
}
cryp.ses = sess.ses;
cryp.len = sizeof(data.in);
cryp.iv = data.iv;
sd_max = sd;
/* Clear the reading and master set */
FD_ZERO(&master);
FD_ZERO(&readfds);
/* Add the proper file descriptors to sets */
FD_SET(sd, &master);
for (;;) {
/* Determine a timeout parameter */
tv.tv_sec = 100;
tv.tv_usec = 0;
readfds = master;
ret = select(sd_max+1, &readfds, NULL, NULL, &tv);
if (ret == -1) {
perror("select");
exit(1);
}
else if (ret == 0) {
fprintf(stderr, "Timeout occured! No data after 1000 seconds!\n");
printf("Attention server shutting down!\n");
goto out;
}
else {
if (FD_ISSET(sd, &readfds)) {
fprintf(stderr, "Waiting for an incoming connection...\n");
/* Accept an incoming connection */
len = sizeof(struct sockaddr_in);
if ((newsd = accept(sd, (struct sockaddr *)&sa, &len)) < 0) {
perror("accept");
exit(1);
}
if (!inet_ntop(AF_INET, &sa.sin_addr, addrstr, sizeof(addrstr))) {
perror("could not format IP address");
exit(1);
}
printf("[%s:%d] logged in.\n", addrstr, ntohs(sa.sin_port));
snprintf((char *) data.in, BUF_SIZE, "[%s:%d]: logged in.\n", addrstr, ntohs(sa.sin_port));
/* encrypt data.in to data.encin */
encrypt_data(cfd,&cryp,&data);
for (ptr = clients; ptr != NULL; ptr = ptr->next) {
n = insist_write(ptr->sd, data.encin, BUF_SIZE);
}
memset(data.in,'\0', BUF_SIZE);
memset(data.encin,'\0', BUF_SIZE);
if (newsd > sd_max)
sd_max = newsd;
FD_SET(newsd, &master);
clients = insert(clients, newsd, addrstr, sa.sin_port);
}
else {
for (ptr = clients; ptr != NULL; ptr = ptr->next) {
if (FD_ISSET(ptr->sd, &readfds)) {
curr_sd = ptr->sd;
n = insist_read(curr_sd, data.encout, BUF_SIZE);
if (n < 0){
perror("read from remote peer failed");
exit(1);
}
if (n == 0) {
printf("[%s:%d] logged out.\n", ptr->addr, ntohs(ptr->port));
snprintf((char *) data.in, BUF_SIZE, "[%s:%d]: logged out.\n", ptr->addr, ntohs(ptr->port));
encrypt_data(cfd,&cryp,&data);
for (ptr2 = clients; ptr2 != NULL; ptr2=ptr2->next) {
if (curr_sd != ptr2->sd) {
n = insist_write(ptr2->sd, data.encin, BUF_SIZE);
}
}
memset(data.in,'\0', BUF_SIZE);
memset(data.encin,'\0', BUF_SIZE);
FD_CLR(curr_sd, &master);
clients = delete(clients, curr_sd);
if (close(curr_sd) < 0) {
perror("close");
exit(1);
}
continue;
}
if (n != BUF_SIZE) {
fprintf(stderr, "Unexpected short read!\n");
exit(1);
}
snprintf((char *) data.in, BUF_SIZE, "[%s:%d]: ", ptr->addr, ntohs(ptr->port));
encrypt_data(cfd,&cryp,&data);
for (ptr2 = clients; ptr2 != NULL; ptr2=ptr2->next) {
n = insist_write(ptr2->sd, data.encin, BUF_SIZE);
n = insist_write(ptr2->sd, data.encout, BUF_SIZE);
}
memset(data.in,'\0', BUF_SIZE);
memset(data.encin,'\0', BUF_SIZE);
memset(data.encout, '\0', BUF_SIZE);
}
}
}
}
}
if (close(sd) < 0) {
perror("close");
exit(1);
}
out:
if (ioctl(cfd, CIOCFSESSION, &sess.ses)) {
perror("ioctl(CIOCFSESSION)");
exit(1);
}
exit(0);
}
int main(void)
{
char addrstr[INET_ADDRSTRLEN];
int sd, newsd;
ssize_t n;
socklen_t len;
struct sockaddr_in sa;
fd_set socks; /* Socket file descriptors we want to wake
up for, using select() */
/* Make sure a broken connection doesn't kill us */
signal(SIGPIPE, SIG_IGN);
/* encryption */
int i;
int crypto_fd;
unsigned char buf[DATA_SIZE], encrypted[DATA_SIZE], decrypted[DATA_SIZE];
unsigned char *key = "0123456789abcdef";
unsigned char *iv = "0123456789abcdef";
struct session_op sess;
struct crypt_op cryp;
memset(&sess, 0, sizeof(sess));
memset(&cryp, 0, sizeof(cryp));
/* encryption */
/* Create TCP/IP socket, used as main chat channel */
if ((sd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}
fprintf(stderr, "Created TCP socket\n");
/* Bind to a well-known port */
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(TCP_PORT);
sa.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
perror("bind");
exit(1);
}
fprintf(stderr, "Bound TCP socket to port %d\n", TCP_PORT);
/* Listen for incoming connections */
if (listen(sd, TCP_BACKLOG) < 0) {
perror("listen");
exit(1);
}
/* Loop forever, accept()ing connections */
for (;;) {
fprintf(stderr, "Waiting for an incoming connection...\n");
/* Accept an incoming connection */
len = sizeof(struct sockaddr_in);
if ((newsd = accept(sd, (struct sockaddr *)&sa, &len)) < 0) {
perror("accept");
exit(1);
}
if (!inet_ntop(AF_INET, &sa.sin_addr, addrstr, sizeof(addrstr))) {
perror("could not format IP address");
exit(1);
}
fprintf(stderr, "Incoming connection from %s:%d\n",
addrstr, ntohs(sa.sin_port));
printf("Remote fd: %d, Local fd: %d\n",newsd , STDIN_FILENO );
printf("\n\nNew Session Started!!!\n\n\n");
crypto_fd = open("/dev/crypto", O_RDWR);
if (crypto_fd < 0) {
perror("open(/dev/crypto)");
return 1;
}
else {
printf("encrypted connection established\n");
}
/* We break out of the loop when the remote peer goes away */
for (;;) {
//printf("ok in loop again\n");
FD_ZERO(&socks);
FD_SET(newsd,&socks);
FD_SET(STDIN_FILENO,&socks);
fprintf(stdout, "me: ");
fflush(stdout);
int readsocks = select(newsd+1, &socks, NULL, NULL, NULL); //&except_socks
/* select() returns the number of sockets that had
things going on with them -- i.e. they're readable. */
/* Once select() returns, the original fd_set has been
modified so it now reflects the state of why select()
woke up. i.e. If file descriptor 4 was originally in
the fd_set, and then it became readable, the fd_set
contains file descriptor 4 in it. */
//printf("readsocks = %d \n", readsocks);
if (readsocks < 0) {
perror("select");
exit(EXIT_FAILURE);
}
else{
/*
* Get crypto session for AES128
*/
/* handle remote input */
if (FD_ISSET(newsd,&socks)){
/*
* Get crypto session for AES128
*/
sess.cipher = CRYPTO_AES_CBC;
sess.keylen = KEY_SIZE;
sess.key = key;
if (ioctl(crypto_fd, CIOCGSESSION, &sess)) {
perror("ioctl(CIOCGSESSION)");
return 1;
}
//printf("Checking remote buffer\n");
n = read(newsd, buf, sizeof(buf));
if (n <= 0) {
if (n < 0)
perror("read from remote peer failed");
else
fprintf(stderr, "\nPeer went away...\n");
break;
}
cryp.ses = sess.ses;
cryp.len = sizeof(buf);
cryp.src = buf;
cryp.dst = decrypted;
cryp.iv = iv;
cryp.op = COP_DECRYPT;
if (ioctl(crypto_fd, CIOCCRYPT, &cryp)) {
perror("ioctl(CIOCCRYPT)");
return 1;
}
fprintf(stdout, "\nRemote: ");
fflush(stdout);
/*if (insist_write(STDOUT_FILENO, buf, n) != n) {
perror("write to local buff failed");
break;
}*/
for (i = 0; i < n; i++) {
if (decrypted[i] == '\n')
break;
else
printf("%c", decrypted[i]);
}
printf("\n");
}
else{ /* handle local-buffer */
/*
* Get crypto session for AES128
*/
sess.cipher = CRYPTO_AES_CBC;
sess.keylen = KEY_SIZE;
sess.key = key;
if (ioctl(crypto_fd, CIOCGSESSION, &sess)) {
perror("ioctl(CIOCGSESSION)");
return 1;
}
//printf("Checking local buffer\n");
n = read(0, buf, sizeof(buf));
if (n <= 0) {
if (n < 0)
perror("read from localy failed");
else
fprintf(stderr, "I went away\n");
break;
}
cryp.ses = sess.ses;
cryp.len = sizeof(buf);
cryp.src = buf;
cryp.dst = encrypted;
cryp.iv = iv;
cryp.op = COP_ENCRYPT;
if (ioctl(crypto_fd, CIOCCRYPT, &cryp)) {
perror("ioctl(CIOCCRYPT)");
return 1;
}
if (insist_write(newsd, encrypted, sizeof(encrypted)) != sizeof(encrypted)) {
perror("write to remote failed");
break;
}
//printf("ok i send the message to remote \n");
}
}
/* Finish crypto session */
if (ioctl(crypto_fd, CIOCFSESSION, &sess.ses)) {
perror("ioctl(CIOCFSESSION)");
return 1;
}
}
/* Make sure we don't leak open files */
if (close(newsd) < 0)
perror("close");
if (close(crypto_fd) < 0) {
perror("close(crypto_fd)");
return 1;
}
}
/* This will never happen */
return 1;
}
int main(int argc, char *argv[])
{
int sd, port;
ssize_t n;
char buf[100];
char *hostname;
struct hostent *hp;
struct sockaddr_in sa;
if (argc != 3) {
fprintf(stderr, "Usage: %s hostname port\n", argv[0]);
exit(1);
}
hostname = argv[1];
port = atoi(argv[2]); /* Needs better error checking */
/* Create TCP/IP socket, used as main chat channel */
if ((sd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}
fprintf(stderr, "Created TCP socket\n");
/* Look up remote hostname on DNS */
if ( !(hp = gethostbyname(hostname))) {
printf("DNS lookup failed for host %s\n", hostname);
exit(1);
}
/* Connect to remote TCP port */
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
memcpy(&sa.sin_addr.s_addr, hp->h_addr, sizeof(struct in_addr));
fprintf(stderr, "Connecting to remote host... "); fflush(stderr);
if (connect(sd, (struct sockaddr *) &sa, sizeof(sa)) < 0) {
perror("connect");
exit(1);
}
fprintf(stderr, "Connected.\n");
/* Be careful with buffer overruns, ensure NUL-termination */
strncpy(buf, HELLO_THERE, sizeof(buf));
buf[sizeof(buf) - 1] = '\0';
/* Say something... */
if (insist_write(sd, buf, strlen(buf)) != strlen(buf)) {
perror("write");
exit(1);
}
fprintf(stdout, "I said:\n%s\nRemote says:\n", buf);
fflush(stdout);
/*
* Let the remote know we're not going to write anything else.
* Try removing the shutdown() call and see what happens.
*/
if (shutdown(sd, SHUT_WR) < 0) {
perror("shutdown");
exit(1);
}
/* Read answer and write it to standard output */
for (;;) {
n = read(sd, buf, sizeof(buf));
if (n < 0) {
perror("read");
exit(1);
}
if (n <= 0)
break;
if (insist_write(0, buf, n) != n) {
perror("write");
exit(1);
}
}
fprintf(stderr, "\nDone.\n");
return 0;
}
