int main()
{
int identifier,on,status;
unsigned int len;
struct sockaddr_in servsock;
char buffer[100],oobdata;
if((identifier=socket(AF_INET,SOCK_STREAM,0))==-1)
{ perror("SOCKET CREATION FAILED!");exit(-1); }
else
{printf("SOCKET CREATION SUCCESS!\n");}
servsock.sin_family=AF_INET;
servsock.sin_port=htons(3035);
servsock.sin_addr.s_addr=INADDR_ANY;
len=sizeof(struct sockaddr_in);
if((bind(identifier,(struct sockaddr *)&servsock,len))==-1)
{ perror("BINDING FAILED!"); exit(-1); }
else
{ printf("SOCKET BINDING SUCCESS!\n");}
status=getsockopt(identifier,SOL_SOCKET,SO_OOBINLINE,&on,&len);
printf("Out of Band Status:%d\n",status);
on =1 ;
len=sizeof(on);
setsockopt(identifier,SOL_SOCKET,SO_OOBINLINE,&on,sizeof(on));
status=sockatmark(identifier);
printf("Status:%d\n",status);
}
int wp_sockatmark (int sockfd)
{
int n;
if ((n = sockatmark (sockfd)) == -1)
wp_warning ("sockatmark() error");
return n;
}
int Sockatmark(int fd)
{
int n;
if ((n = sockatmark(fd)) < 0) err_sys("sockatmark 错误");
return (n);
}
void sig_urg(int signo)
{
int n,skiped=0;
char buf[100];
fprintf(stderr, "SIGURG received\n");
while(1) {
n = sockatmark(connfd);
if(n==1) {
fprintf(stderr, "at OOB mark: ");
n = recv(connfd,buf,sizeof(buf-1),MSG_OOB);
if (n<0)
err_exit("recv error");
else
fprintf(stderr, "OOB=%c,",buf[0]);
fprintf(stderr, "skiped %d bytes before OOB\n",skiped);
return;
} else if (n<0)
err_exit("sockatmark error");
else {
n=read(connfd,buf,sizeof(buf)-1);
skiped=skiped+n;
}
}
}
int
Sockatmark(int fd)
{
int n;
if ( (n = sockatmark(fd)) < 0)
err_sys("sockatmark error: %s", strerror(errno));
return(n);
}
int
sys_sockatmark(struct lwp *l, const struct sys_sockatmark_args *uap, register_t *retval)
{
int re;
(void)l;
re = sockatmark(SCARG(uap, sd));
*retval = re;
return 0;
}
//## int System.sockatmark(int socket);
KMETHOD System_sockatmark(KonohaContext *kctx, KonohaStack* sfp)
{
int ret = sockatmark(WORD2INT(sfp[1].intValue));
if(ret < 0) {
OLDTRACE_SWITCH_TO_KTrace(_SystemFault,
LogText("@", "sockadmark"),
LogUint("errno", errno),
LogText("errstr", strerror(errno))
);
}
KReturnUnboxValue(ret);
}
int main(int argc, char **argv)
{
int n, listenfd, connfd, mark;
char buff[100];
struct sockaddr_in serv;
const int on = 1;
if (argc != 2)
err_quit("oob_serv01 <port#>");
listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listenfd < 0) err_sys("socket() error");
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_addr.s_addr = htonl(INADDR_ANY);
serv.sin_port = htons(atoi(argv[1]));
if (bind(listenfd, (SA *)&serv, sizeof(serv)) < 0)
err_sys("bind error");
if (listen(listenfd, 4096) < 0)
err_sys("listen() error");
if (setsockopt(listenfd, SOL_SOCKET, SO_OOBINLINE, &on, sizeof(on)) < 0)
err_sys("setsockopt SO_OOBINLINE error");
connfd = accept(listenfd, NULL, NULL);
if (connfd < 0)
err_sys("accept() error");
sleep(5);
for (;;) {
if ((mark = sockatmark(connfd)) < 0)
err_sys("sockatmark error");
if (mark)
printf("at OOB mark\n");
if ( (n = read(connfd, buff, sizeof(buff)-1)) <= 0 ) {
if (n < 0) err_sys("read() error");
printf("received EOF\n");
exit(0);
}
buff[n] = 0;
printf("read %d bytes: %s\n", n, buff);
}
}
void recvFile(char *hostName, unsigned int port)
{
struct sockaddr_in sin;
if ((serverSocketFd =
createTcpServerSocket(hostName, port, &sin, 5)) == -1) {
printf("Creation socket error\n");
exit(EXIT_FAILURE);
}
char replyBuf[replyBufSize], buf[bufSize];
while (1) {
printf("\nServer started.\n");
remoteSocketFd =
accept(serverSocketFd, NULL, NULL);
struct sigaction urgSignal;
urgSignal.sa_handler = urgHandler;
sigaction(SIGURG, &urgSignal, NULL);
if (fcntl(remoteSocketFd, F_SETOWN, getpid()) < 0) {
perror("fcntl()");
exit(-1);
}
// Receive file name and file size
if (ReceiveToBuf
(remoteSocketFd, replyBuf, sizeof(replyBuf)) <= 0) {
close(remoteSocketFd);
fprintf(stderr, "Error receiving file name and file size\n");
continue;
}
char *fileName = strtok(replyBuf, ":");
if (fileName == NULL) {
close(remoteSocketFd);
fprintf(stderr, "Bad file name\n");
continue;
}
char *size = strtok(NULL, ":");
if (size == NULL) {
close(remoteSocketFd);
fprintf(stderr, "Bad file size\n");
continue;
}
long fileSize = atoi(size);
printf("File size: %ld, file name: %s\n", fileSize, fileName);
FILE *file = CreaterecvFile(fileName, "Temp_files");
if (file == NULL) {
perror("Create file error");
exit(EXIT_FAILURE);
}
// Receiving file
int recvSize;
long totalBytesReceived = 0;
while (totalBytesReceived < fileSize) {
if (sockatmark(remoteSocketFd) == 1 && oobFlag == 1) {
printf("Receive OOB byte. Total bytes received: %ld\n",
totalBytesReceived);
char oobBuf;
int n = recv(remoteSocketFd, &oobBuf, 1, MSG_OOB);
if (n == -1)
fprintf(stderr, "receive OOB error\n");
oobFlag = 0;
}
recvSize = recv(remoteSocketFd, buf, sizeof(buf), 0);
if (recvSize > 0) {
totalBytesReceived += recvSize;
fwrite(buf, 1, recvSize, file);
} else if (recvSize == 0) {
printf("Received EOF\n");
break;
} else {
if (errno == EINTR)
continue;
else {
perror("receive error");
break;
}
}
}
fclose(file);
printf("Receiving file finished. %ld bytes received.\n",
totalBytesReceived);
close(remoteSocketFd);
}
}
int VMPI_sockatmark(int s)
{
return sockatmark( s );
}
void get_file_tcp(char* host, int port) {
struct sockaddr_in client_address;
memset(&client_address, 0, sizeof(client_address));
client_address.sin_family = AF_INET;
struct hostent* host_name = gethostbyname(host);
if (host_name != NULL) {
memcpy(&client_address.sin_addr, host_name->h_addr, host_name->h_length);
} else {
print_error("Invalid client host", 8);
}
client_address.sin_port = htons(port);
struct protoent* protocol_type = getprotobyname("TCP");
server_socket_descriptor = socket(AF_INET, SOCK_STREAM, protocol_type->p_proto);
if (server_socket_descriptor < 0) {
print_error("Can't create server socket", 9);
}
int bool_option = 1;
if (setsockopt(server_socket_descriptor,
SOL_SOCKET, SO_REUSEADDR, &bool_option, sizeof(int)) == -1) {
print_error("Can't set reuse address socket option", 10);
}
if (bind(server_socket_descriptor, (struct sockaddr*) &client_address, sizeof(client_address)) < 0) {
print_error("Can't bind socket", 11);
}
if (listen(server_socket_descriptor, MAX_LENGTH) == -1) {
print_error("Listen socket error", 12);
}
char header_buffer[ADDITIONAL_BUFFER_SIZE], buffer[BUFFER_SIZE];
while (1) {
printf("\nTCP server waiting\n");
int descriptor = accept(server_socket_descriptor, NULL, NULL);
struct sigaction urg_signal;
urg_signal.sa_handler = urg_handler;
sigaction(SIGURG, &urg_signal, NULL);
if (fcntl(descriptor, F_SETOWN, getpid()) < 0) {
print_error("fcntl", 21);
}
if (save_data_to_buffer(descriptor, header_buffer, sizeof(header_buffer)) <= 0) {
close(descriptor);
printf("Error in sending header\n");
continue;
}
char *file_name = strtok(header_buffer, ":");
if (file_name == NULL) {
close(descriptor);
printf("Error in file name\n");
continue;
}
char *size = strtok(NULL, ":");
if (size == NULL) {
close(descriptor);
printf("Error in file size\n");
continue;
}
long file_size = atoi(size);
FILE *file = create_file(file_name, "temp_folder");
if (file == NULL) {
print_error("Error in creating file", 11);
}
fd_set server_fds;
FD_ZERO(&server_fds);
FD_SET(descriptor, &server_fds);
struct timespec timeout;
timeout.tv_sec = 10;
timeout.tv_nsec = 0;
int temp = 1;
long get_length = 0;
int read_length;
while (1) {
if (sockatmark(descriptor) == 1 && oob_flag == 1) {
printf("Receive OOB byte. Total bytes received: %ld\n", get_length);
char oobBuf;
int n = recv(descriptor, &oobBuf, 1, MSG_OOB);
if (n == -1) {
fprintf(stderr, "receive OOB error\n");
}
oob_flag = 0;
}
read_length = recv(descriptor, buffer, sizeof(buffer), 0);
temp = pselect(descriptor + 1, NULL, &server_fds, NULL, &timeout, NULL);
if (temp == 0 || temp == -1){
close(descriptor);
fclose(file);
print_error("Connection terminated\n", 666);
}
if (read_length == 0) {
break;
} else if (read_length > 0) {
fwrite(buffer, 1, read_length, file);
get_length += read_length;
} else if (errno == EINTR) {
continue;
} else {
printf("Unknown error");
break;
}
}
fclose(file);
printf("File obtained: %ld", get_length);
close(descriptor);
}
}
