int main() {
//用于丢包率的随机数种子
srand(time(NULL));
//连接到SIP进程并获得TCP套接字描述符
int sip_conn = connectToSIP();
if(sip_conn<0) {
printf("can not connect to the local SIP process\n");
}
//初始化STCP服务器
stcp_server_init(sip_conn);
//在端口SERVERPORT1上创建STCP服务器套接字
int sockfd= stcp_server_sock(SERVERPORT1);
if(sockfd<0) {
printf("can't create stcp server\n");
exit(1);
}
//监听并接受来自STCP客户端的连接
stcp_server_accept(sockfd);
//在端口SERVERPORT2上创建另一个STCP服务器套接字
int sockfd2= stcp_server_sock(SERVERPORT2);
if(sockfd2<0) {
printf("can't create stcp server\n");
exit(1);
}
//监听并接受来自STCP客户端的连接
stcp_server_accept(sockfd2);
char buf1[6];
char buf2[7];
int i;
//接收来自第一个连接的字符串
for(i=0;i<5;i++) {
stcp_server_recv(sockfd,buf1,6);
printf("recv string: %s from connection 1\n",buf1);
}
//接收来自第二个连接的字符串
for(i=0;i<5;i++) {
stcp_server_recv(sockfd2,buf2,7);
printf("recv string: %s from connection 2\n",buf2);
}
sleep(WAITTIME);
//关闭STCP服务器
if(stcp_server_close(sockfd)<0) {
printf("can't destroy stcp server\n");
exit(1);
}
if(stcp_server_close(sockfd2)<0) {
printf("can't destroy stcp server\n");
exit(1);
}
//断开与SIP进程之间的连接
disconnectToSIP(sip_conn);
}
int main() {
//用于丢包率的随机数种子
srand(time(NULL));
//启动重叠网络层并获取重叠网络层TCP套接字描述符
int son_conn = son_start();
if(son_conn<0) {
printf("can not start overlay network\n");
}
//初始化STCP服务器
stcp_server_init(son_conn);
//在端口SERVERPORT1上创建STCP服务器套接字
int sockfd= stcp_server_sock(SERVERPORT1);
if(sockfd<0) {
printf("can't create stcp server\n");
exit(1);
}
//监听并接受来自STCP客户端的连接
stcp_server_accept(sockfd);
//在端口SERVERPORT2上创建另一个STCP服务器套接字
int sockfd2= stcp_server_sock(SERVERPORT2);
if(sockfd2<0) {
printf("can't create stcp server\n");
exit(1);
}
//监听并接受来自STCP客户端的连接
stcp_server_accept(sockfd2);
char buf1[6];
char buf2[7];
int i;
//接收来自第一个连接的字符串
for(i=0;i<5;i++) {
stcp_server_recv(sockfd,buf1,6);
printf("recv string: %s from connection 1\n",buf1);
}
//接收来自第二个连接的字符串
for(i=0;i<5;i++) {
stcp_server_recv(sockfd2,buf2,7);
printf("recv string: %s from connection 2\n",buf2);
}
//sleep(WAITTIME);
//关闭STCP服务器
if(stcp_server_close(sockfd)<0) {
printf("can't destroy stcp server\n");
exit(1);
}
if(stcp_server_close(sockfd2)<0) {
printf("can't destroy stcp server\n");
exit(1);
}
//停止重叠网络层
son_stop(son_conn);
}
int main() {
//用于丢包率的随机数种子
srand(time(NULL));
//启动重叠网络层并获取重叠网络层TCP套接字描述符
int son_conn = son_start();
if(son_conn<0) {
printf("can not start overlay network\n");
}
//初始化STCP服务器
stcp_server_init(son_conn);
//在端口SERVERPORT1上创建STCP服务器套接字
int sockfd= stcp_server_sock(SERVERPORT1);
if(sockfd<0) {
printf("can't create stcp server\n");
exit(1);
}
//监听并接受来自STCP客户端的连接
stcp_server_accept(sockfd);
//在端口SERVERPORT2上创建另一个STCP服务器套接字
int sockfd2= stcp_server_sock(SERVERPORT2);
if(sockfd2<0) {
printf("can't create stcp server\n");
exit(1);
}
//监听并接受来自STCP客户端的连接
stcp_server_accept(sockfd2);
sleep(WAITTIME);
//关闭STCP服务器
if(stcp_server_close(sockfd)<0) {
printf("can't destroy stcp server\n");
exit(1);
}
if(stcp_server_close(sockfd2)<0) {
printf("can't destroy stcp server\n");
exit(1);
}
//停止重叠网络层
son_stop(son_conn);
}
int main(int argc, char*argv[])
{
int i;
//用于丢包率的随机数种子
srand(time(NULL));
//连接到SIP进程并获得TCP套接字描述符
int sip_conn = connectToSIP();
if(sip_conn<0) {
printf("can not connect to the local SIP process\n");
}
//初始化STCP服务器
stcp_server_init(sip_conn);
//在端口SERVERPORT1上创建STCP服务器套接字
stcp_server_sock(SERV_PORT);
int rc;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE);
printf("====server start=====\n");
while (1)
{
int newsockfd = stcp_server_accept();
if (newsockfd < 0)
{
perror("ERROR on accept");
exit(1);
}
printf("%d link in..\n",newsockfd);
/* Create child process */
user * p=(user *)malloc(sizeof(user));
p->sock=newsockfd;
p->state=1;
for(i=0;i<LISTENQ;i++)
{
p->fri[i]=NULL;
}
pthread_mutex_init(&p->usrlock, NULL);
rc=pthread_create(&p->id,&attr,GetTask,(void*)p);
if(rc){
printf("ERROE;return code from pthread_c reate() is %d\n",rc);
}
rc=pthread_create(&p->id,&attr,GiveTask,(void*)p);
pthread_mutex_unlock(&lock);
if(rc){
printf("ERROE;return code from pthread_c reate() is %d\n",rc);
}
} /* end of while */
pthread_attr_destroy(&attr);
pthread_exit(NULL);
}
int main() {
//用于丢包率的随机数种子
srand(time(NULL));
//启动重叠网络层并获取重叠网络层TCP套接字描述符
int son_conn = son_start();
if(son_conn<0) {
printf("can not start overlay network\n");
}
//初始化STCP服务器
stcp_server_init(son_conn);
//在端口SERVERPORT1上创建STCP服务器套接字
int sockfd= stcp_server_sock(SERVERPORT1);
if(sockfd<0) {
printf("can't create stcp server\n");
exit(1);
}
//监听并接受来自STCP客户端的连接
stcp_server_accept(sockfd);
//首先接收文件长度, 然后接收文件数据
int fileLen;
stcp_server_recv(sockfd,&fileLen,sizeof(int));
printf("get file length: %d\n",fileLen);
char* buf = (char*) malloc(fileLen);
stcp_server_recv(sockfd,buf,fileLen);
//int i=0;
/*for(;i<fileLen;i++)
{
printf("%c",buf[i]);
}*/
//将接收到的文件数据保存到文件receivedtext.txt中
FILE* f;
f = fopen("receivedtext.txt","w");
fwrite(buf,fileLen,1,f);
fclose(f);
free(buf);
sleep(WAITTIME);
//关闭STCP服务器
if(stcp_server_close(sockfd)<0) {
printf("can't destroy stcp server\n");
exit(1);
}
//停止重叠网络层
son_stop(son_conn);
}
int main() {
//用于丢包率的随机数种子
srand(time(NULL));
//连接到SIP进程并获得TCP套接字描述符
int sip_conn = connectToSIP();
if(sip_conn<0) {
printf("can not connect to the local SIP process\n");
}
//初始化STCP服务器
stcp_server_init(sip_conn);
//在端口SERVERPORT1上创建STCP服务器套接字
int sockfd= stcp_server_sock(SERVERPORT1);
if(sockfd<0) {
printf("can't create stcp server\n");
exit(1);
}
//监听并接受来自STCP客户端的连接
stcp_server_accept(sockfd);
//首先接收文件长度, 然后接收文件数据
int fileLen;
stcp_server_recv(sockfd,&fileLen,sizeof(int));
char* buf = (char*) malloc(fileLen);
stcp_server_recv(sockfd,buf,fileLen);
//将接收到的文件数据保存到文件receivedtext.txt中
FILE* f;
f = fopen("receivedtext.txt","a");
fwrite(buf,fileLen,1,f);
fclose(f);
free(buf);
//等待一会儿
sleep(WAITTIME);
//关闭STCP服务器
if(stcp_server_close(sockfd)<0) {
printf("can't destroy stcp server\n");
exit(1);
}
//断开与SIP进程之间的连接
disconnectToSIP(sip_conn);
}
int main() {
//用于丢包率的随机数种子
srand(time(NULL));
//连接到SIP进程并获得TCP套接字描述符
int sip_conn = connectToSIP();
if(sip_conn<0) {
printf("can not connect to the local SIP process\n");
}
//初始化STCP服务器
stcp_server_init(sip_conn);
//启动seghandler线程
pthread_t seghandle_thread;
int rc;
rc = pthread_create(&seghandle_thread, NULL, seghandler, &sip_conn);
if (rc) {
printf("ERROR; return code from pthread_create() is %d\n", rc);
exit(-1);
}
//在端口SERVERPORT1上创建STCP服务器套接字
int sockfd= stcp_server_sock(SERVERPORT1);
if(sockfd<0) {
printf("can't create stcp server\n");
exit(1);
}
//监听并接受来自STCP客户端的连接
stcp_server_accept(sockfd);
char hostname[50];
printf("Enter server name to connect:");
scanf("%s",hostname);
int server_nodeID = topology_getNodeIDfromname(hostname);
if(server_nodeID == -1) {
printf("host name error!\n");
exit(1);
} else {
printf("connecting to node %d\n",server_nodeID);
}
//在端口87上创建STCP客户端套接字, 并连接到STCP服务器端口88
int sockfd2 = stcp_client_sock(CLIENTPORT1);
if(sockfd2<0) {
printf("fail to create stcp client sock");
exit(1);
}
if(stcp_client_connect(sockfd2,server_nodeID,SERVERPORT1)<0) {
printf("fail to connect to stcp server\n");
exit(1);
}
char buf1[6];
//接收来自第一个连接的字符串
int i;
for(i=0;i<5;i++) {
stcp_server_recv(sockfd,buf1,6);
printf("recv string: %s from connection 1\n",buf1);
}
//通过第二个连接发送字符串
char mydata2[7] = "byebye";
for(i=0;i<5;i++){
stcp_client_send(sockfd2, mydata2, 7);
printf("send string:%s to connection 2\n",mydata2);
}
sleep(WAITTIME);
//关闭STCP服务器
if(stcp_server_close(sockfd)<0) {
printf("can't destroy stcp server\n");
exit(1);
}
sleep(WAITTIME);
//关闭连接
if(stcp_client_disconnect(sockfd2)<0) {
printf("fail to disconnect from stcp server\n");
exit(1);
}
//断开与SIP进程之间的连接
disconnectToSIP(sip_conn);
}
