API tools faq
paste
Guest User

Untitled

a guest
Nov 6th, 2016
44
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 37.21 KB | None | 0 0
raw download clone embed print report
  1. ********/*program OSI MODEL*/***************************************************
  2. OSI
  3. #include<stdio.h>
  4.  
  5. void main()
  6. {
  7. //clrscr();
  8. printf(“\n \t\t ISO-OSI Model”);
  9. printf(“\n LAYERS Sender Side”);
  10.  
  11. printf(“\n APPLICATION lAYER !! AH !!DATA!!”);
  12. sleep(1);
  13. printf(“\n PRESENTATION lAYER !! PH !!AH!!DATA!!”);
  14. sleep(1);
  15. printf(“\n SESSION LAYER !! SH !!PH!!AH!!DATA!!”);
  16. sleep(1);
  17. printf(“\n TRANSPORT LAYER !! TH !!SH!!PH!!AH!!DATA!!”);
  18. sleep(1);
  19. printf(“\n NETWORK LAYER !! NH !!TH!!SH!!PH!!AH!!DATA!!”);
  20. sleep(1);
  21. printf(“\n DATALINK LAYER !! DH !!NH!!TH!!SH!!PH!!AH!!DATA!! CRC !!”);
  22. sleep(1);
  23. printf(“\n PHYSICAL LAYER 100100101010101110001010010 \n”);
  24. sleep(1);
  25. printf(“\n LAYERS Recevier Side”);
  26. printf(“\n PHYSICAL LAYER 100100101010101110001010010 “);
  27. sleep(1);
  28. printf(“\n DATALINK LAYER !! DH !!NH!!TH!!SH!!PH!!AH!!DATA!! CRC !!”);
  29. sleep(1);
  30. printf(“\n NETWORK LAYER !! NH !!TH!!SH!!PH!!AH!!DATA!!”);
  31. sleep(1);
  32. printf(“\n TRANSPORT LAYER !! TH !!SH!!PH!!AH!!DATA!!”);
  33. sleep(1);
  34. printf(“\n SESSION LAYER !! SH !!PH!!AH!!DATA!!”);
  35. sleep(1);
  36. printf(“\n PRESENTATION lAYER !! PH !!AH!!DATA!!”);
  37. sleep(1);
  38. printf(“\n APPLICATION lAYER !! AH !!DATA!!”);
  39. sleep(1);
  40. //getch();
  41. }
  42.  
  43. *********************/*PROGRAM Character Oount*/********************************
  44. CHARECTER COUNT
  45. #include<stdio.h>
  46. #include<conio.h>
  47. #include<string.h>
  48. void main()
  49. {
  50. int i,j,k,n,c=0,l;
  51. char s[20];
  52. clrscr();
  53. printf("\t enter the string \n\t");
  54. gets(s);
  55. l=strlen(s);
  56. printf("\t%d",l);
  57. printf("\n\n");
  58. j=0;
  59. printf(" \tenter the frame size: \t ");
  60. scanf("%d",&n);
  61. k=l/n;
  62. for(i=0;i<k;i++)
  63. {
  64. printf("\t DLESTX");
  65. while(j<l)
  66. {
  67.  
  68. putchar(s[j]);
  69. c++;
  70. j++;
  71. if(c==n)
  72. break;
  73. }
  74. printf(" DLESTX \t");
  75. printf("\n\n");
  76. c=0;
  77. }
  78. getch();
  79.  
  80. //PROGRAMME CHARECTER COUNT(2)
  81.  
  82. #include <stdio.h>
  83. #include <string.h>
  84.  
  85. int main()
  86. {
  87. char string[100];
  88. int c = 0, count[26] = {0};
  89.  
  90. printf("Enter a string\n");
  91. gets(string);
  92.  
  93. while (string[c] != '\0')
  94. {
  95. /** Considering characters from 'a' to 'z' only
  96. and ignoring others */
  97.  
  98. if (string[c] >= 'a' && string[c] <= 'z')
  99. count[string[c]-'a']++;
  100.  
  101. c++;
  102. }
  103.  
  104. for (c = 0; c < 26; c++)
  105. {
  106. /** Printing only those characters
  107. whose count is at least 1 */
  108.  
  109. if (count[c] != 0)
  110. printf("%c occurs %d times in the entered string.\n",c+'a',count[c]);
  111. }
  112.  
  113. return 0;
  114. }
  115. ***************************CHECKSUM*********************************************
  116. CHECKSUM
  117. #include<stdio.h>
  118. #include<conio.h>
  119. #include<math.h>
  120.  
  121. int sender(int b[10],int k)
  122. {
  123. int checksum,sum=0,i;
  124. printf("\n****SENDER****\n");
  125.  
  126. for(i=0;i<k;i++)
  127. sum+=b[i];
  128. printf("SUM IS: %d",sum);
  129.  
  130. checksum=~sum;
  131. printf("\nSENDER's CHECKSUM IS:%d",checksum);
  132. return checksum;
  133. }
  134.  
  135. int receiver(int c[10],int k,int scheck)
  136. {
  137. int checksum,sum=0,i;
  138. printf("\n\n****RECEIVER****\n");
  139. for(i=0;i<k;i++)
  140. sum+=c[i];
  141. printf(" RECEIVER SUM IS:%d",sum);
  142. sum=sum+scheck;
  143. checksum=~sum;
  144. printf("\nRECEIVER's CHECKSUM IS:%d",checksum);
  145. return checksum;
  146. }
  147. main()
  148. {
  149. int a[10],i,m,scheck,rcheck;
  150. printf("\nENTER SIZE OF THE STRING:");
  151. scanf("%d",&m);
  152. printf("\nENTER THE ELEMENTS OF THE ARRAY:");
  153. for(i=0;i<m;i++)
  154. scanf("%d",&a[i]);
  155. scheck=sender(a,m);
  156. rcheck=receiver(a,m,scheck);
  157. if(rcheck==0)
  158. printf("\n\nNO ERROR IN TRANSMISSION\n\n");
  159. else
  160. printf("\n\nERROR DETECTED");
  161. getch();
  162. }
  163. *******************************CRC**********************************************
  164. CRC
  165. #include <stdio.h>
  166. #include <string.h>
  167. void main()
  168. {
  169. int i,j,keylen,msglen;
  170. char input[100], key[30],temp[30],quot[100],rem[30],key1[30];
  171. printf("Enter Data: ");
  172. gets(input);
  173. printf("Enter Key: ");
  174. gets(key);
  175. keylen=strlen(key);
  176. msglen=strlen(input);
  177. strcpy(key1,key);
  178. for(i=0;i<keylen-1;i++)
  179. {
  180. input[msglen+i]='0';
  181. }
  182. for(i=0;i<keylen;i++)
  183. temp[i]=input[i];
  184. for(i=0;i<msglen;i++)
  185. {
  186. quot[i]=temp[0];
  187. if(quot[i]=='0')
  188. for(j=0;j<keylen;j++)
  189. key[j]='0';
  190. else
  191. for(j=0;j<keylen;j++)
  192. key[j]=key1[j];
  193. for(j=keylen-1;j>0;j--)
  194. {
  195. if(temp[j]==key[j])
  196. rem[j-1]='0';
  197. else
  198. rem[j-1]='1';
  199. }
  200. rem[keylen-1]=input[i+keylen];
  201. strcpy(temp,rem);
  202. }
  203. strcpy(rem,temp);
  204. printf("\nQuotient is ");
  205. for(i=0;i<msglen;i++)
  206. printf("%c",quot[i]);
  207. printf("\nRemainder is ");
  208. for(i=0;i<keylen-1;i++)
  209. printf("%c",rem[i]);
  210. printf("\nFinal data is: ");
  211. for(i=0;i<msglen;i++)
  212. printf("%c",input[i]);
  213. for(i=0;i<keylen-1;i++)
  214. printf("%c",rem[i]);
  215. }
  216. ********************************HAMMING CODE**********************************
  217. HAMMING CODE
  218. #include<stdio.h>
  219. #include<math.h>
  220. int main()
  221. {
  222. int a[20],b[20],c[20],d[20],i,k,m,f,n,j,r,p,x,y,z,ch,key,q,v,sum=0;
  223. system("clear");
  224. printf("\n ENTER THE LENGTH OF DATA WORD :");
  225. scanf("%d",&k);
  226. printf("\n ENTER THE DATA WORD \n");
  227. for(i=1; i<=k; i++){
  228. scanf("%d",&a[i]);
  229. }
  230. m=1;
  231. while((k+m+1)>=pow(2,m)){
  232. m++;
  233. }
  234. printf("\n Value of m is : %d",m);
  235. n=k+m;
  236. j=1; r=0;
  237. for(i=1; i<=n; i++){
  238. p=pow(2,r);
  239. if(i==p){
  240. b[i]=0;
  241. r++;
  242. }
  243. else{
  244. b[i]=a[j];
  245. j++;
  246. }
  247. }
  248. printf("\n INTERMEDIATE CODE WORD IS \n");
  249. for(i=1; i<=n; i++)
  250. printf("%d",b[i]);
  251. p=0;
  252. for(i=1; i<=m; i++)
  253. {
  254. x=pow(2,p); r=1;
  255. for(j=x; j<=n; j=j+(x*2)){
  256. for(y=j; y<(j+x); y++){
  257. c[r]=b[y];
  258. r++;
  259. }
  260. }
  261. z=0;
  262. for(y=1; y<=(r-1); y++)
  263. {
  264. if(c[y]==1) z++;
  265. }
  266. if(z%2==0)
  267. b[x]=0;
  268. else
  269. b[x]=1;
  270. for(y=1; y<=20; y++)
  271. c[y]=0;
  272. p++;
  273. }
  274. printf("\n\n THE HAMMING CODE IS \n");
  275. for(i=1; i<=n; i++)
  276. printf("%d",b[i]);
  277. while(1){
  278. printf("\n\n PRESS 1 TO ALTER A BIT 0 to EXIT \n\n");
  279. scanf("%d",&ch);
  280. if(ch==1){
  281. printf("\n ENTER THE BIT YOU WANT TO CHANGE \n");
  282. scanf("%d",&key);
  283. for(i=1; i<=n; i++){
  284. if(i==key){
  285. if(b[key]==1) b[key]=0;
  286. else b[key]=1;
  287. break;
  288. }
  289. }
  290. printf("\n THE NEW CODE IS \n\n");
  291. for(i=1; i<=n; i++)
  292. printf("%d",b[i]);
  293. }
  294. else
  295. break;
  296. }
  297. p=0; q=0;
  298. for(i=1; i<=m; i++)
  299. {
  300. x=pow(2,p); r=1;
  301. for(j=x; j<=n; j=j+(x*2)){
  302. for(y=j; y<(j+x); y++){
  303. c[r]=b[y];
  304. r++;
  305. }
  306. }
  307. z=0;
  308. for(y=1; y<=(r-1); y++)
  309. {
  310. if(c[y]==1) z++;
  311. }
  312. v=z%2;
  313. d[q]=v;
  314. sum=sum+(v*pow(2,q));
  315. q++;
  316. for(y=1; y<=20; y++)
  317. c[y]=0;
  318. p++;
  319. }
  320. if(sum==0)
  321. printf("\n\n NO ERROR FOUND....... \n\n");
  322. else
  323. printf("\n\n ERROR AT POSITION %d",sum);
  324. printf("\n");
  325. return 0;
  326. }
  327. *******************************************************************************
  328. //BIT STUFF
  329.  
  330. #include<stdio.h>
  331.  
  332. int main()
  333. {
  334. int i=0,count=0;
  335. char a[100];
  336. printf("enter the bits : ");
  337. scanf("%s",a);
  338.  
  339. printf("\nAfter bit stuffing \n");
  340. printf("01111110");
  341.  
  342. for(i=0;a[i]; i++)
  343. {
  344. if(a[i]=='1')
  345. count++;
  346. else
  347. count=0;
  348. printf("%c",a[i]);
  349. if(count==5)
  350. {
  351. printf("0");
  352. count=0;
  353. }
  354. }
  355. printf("01111110");
  356. return 1;
  357. }
  358. ********************************************************************************
  359. BYTE STUFFING
  360.  
  361. #include<stdio.h>
  362. #include<string.h>
  363. void main()
  364. {
  365. char frame[100],str[50][50];
  366. char DLE='*';
  367. char STX='#';
  368. char ETX='$';
  369. int i,j,k=0,n;
  370. frame[k++]='*';
  371. frame[k++]='#';
  372. printf("Here DLE is * \n STX is #\n and ETX is $\n");
  373. printf("Enter no.of String ::\t");
  374. scanf("%d",&n);
  375. printf("Enter String \n");
  376. for(i=0;i<=n;i++)
  377. {
  378. gets(str[i]);
  379. }
  380. printf("You entered ::\n");
  381. for(i=0;i<=n;i++)
  382. {
  383. puts(str[i]);
  384. }
  385.  
  386. printf("\n");
  387. for(i=1;i<=n;i++)
  388. {
  389. for(j=0;j<strlen(str[i]);j++)
  390. {
  391. if(str[i][j]!=DLE)
  392. {
  393. frame[k++]=str[i][j];
  394. }
  395. else{
  396. frame[k++]='*';
  397. frame[k++]=str[i][j];
  398. }
  399. }
  400. }
  401. frame[k++]='*';
  402. frame[k++]='$';
  403. frame[k++]='\0';
  404. printf("------------------------------\n");
  405. printf("Byte stuffing at sender side:\n");
  406. printf("------------------------------\n");
  407.  
  408. for(i=0;i<k;i++)
  409. {
  410. printf("%c",frame[i]);
  411. }
  412.  
  413. printf("\n------------------------------");
  414. printf("\nByte stuffing at receiver side\n");
  415. printf("------------------------------\n");
  416. for(i=0;i<k;i++)
  417. {
  418. if(frame[i]=='#'|| frame[i]=='$')
  419.  
  420. ********************************************************************************
  421. ***************/*PROGRAM: CHARACTER STUFFING AND DE-STUFFING*/******************
  422.  
  423. #include
  424. #include
  425. #include
  426. void charc(void);
  427. void main()
  428. {
  429. int choice;
  430. while(1)
  431. {
  432. printf("\n\n\n1.character stuffing");
  433. printf("\n\n2.exit");
  434. printf("\n\n\nenter choice");
  435. scanf("%d",&choice);
  436. printf("%d",choice);
  437. if(choice>2)
  438. printf("\n\n invalid option....please renter");
  439. switch(choice)
  440. {
  441. case 1:
  442. charc();
  443. break;
  444. case 2:
  445. exit(0);
  446. }
  447. }
  448. }
  449. void charc(void)
  450. {
  451. char c[50],d[50],t[50];
  452. int i,m,j;
  453. clrscr();
  454. printf("enter the number of characters\n");
  455. scanf("%d",&m);
  456. printf("\n enter the characters\n");
  457. for(i=0;i {
  458. scanf("%c",&c[i]);
  459. }
  460. printf("\n original data\n");
  461. for(i=0;i printf("%c",c[i]);
  462. d[0]='d';
  463. d[1]='l';
  464. d[2]='e';
  465. d[3]='s';
  466. d[4]='t';
  467. d[5]='x';
  468. for(i=0,j=6;i {
  469. if((c[i]=='d'&&c[i+1]=='l'&& c[i+2]=='e'))
  470. {
  471. d[j]='d';
  472. j++;
  473. d[j]='l';
  474. j++;
  475. d[j]='e';
  476. j++;
  477. m=m+3;
  478. }
  479. d[j]=c[i];
  480. }
  481. m=m+6;
  482. m++;
  483. d[m]='d';
  484. m++;
  485. d[m]='l';
  486. m++;
  487. d[m]='e';
  488. m++;
  489. d[m]='e';
  490. m++;
  491. d[m]='t';
  492. m++;
  493. d[m]='x';
  494. m++;
  495. printf("\n\n transmitted data: \n");
  496. for(i=0;i {
  497. printf("%c",d[i]);
  498. }
  499. for(i=6,j=0;i {
  500. if(d[i]=='d'&&d[i+1]=='l'&&d[i+2]=='e'&&d[i+3]=='d'&&d[i+4]=='l'&&d[i+5]=='e')
  501. i=i+3;
  502. t[j]=d[i];
  503. }
  504. printf("\n\nreceived data:");
  505. for(i=0;i {printf("%c",t[i]);
  506. }
  507. }
  508.  
  509. *******************************************************************************
  510. ***************/* Program TO BIT STUFFING AND DE-STUFFING*/*********************
  511.  
  512. #include<stdio.h>
  513. #include<stdlib.h>
  514. #define MAXSIZE 100
  515.  
  516. int main()
  517. {
  518. char *p,*q;
  519. char temp;
  520. char in[MAXSIZE];
  521. char stuff[MAXSIZE];
  522. char destuff[MAXSIZE];
  523.  
  524. int count=0;
  525.  
  526. printf("enter the input character string (0‘s & 1‘s only):\n");
  527. scanf("%s",in);
  528.  
  529. p=in;
  530. q=stuff;
  531.  
  532. while(*p!='\0')
  533. {
  534. if(*p=='0')
  535. {
  536. *q=*p;
  537. q++;
  538. p++;
  539. }
  540. else
  541. {
  542. while(*p=='1' && count!=5)
  543. {
  544. count++;
  545. *q=*p;
  546. q++;
  547. p++;
  548. }
  549.  
  550. if(count==5)
  551. {
  552. *q='0';
  553. q++;
  554. }
  555. count=0;
  556. }
  557. }
  558. *q='\0';
  559. printf("\nthe stuffed character string is");
  560. printf("\n%s",stuff);
  561.  
  562. p=stuff;
  563. q=destuff;
  564. while(*p!='\0')
  565. {
  566. if(*p=='0')
  567. {
  568. *q=*p;
  569. q++;
  570. p++;
  571. }
  572. else
  573. {
  574. while(*p=='1' && count!=5)
  575. {
  576. count++;
  577. *q=*p;
  578. q++;
  579. p++;
  580. }
  581. if(count==5)
  582. {
  583. p++;
  584. }
  585. count=0;
  586. }
  587. }
  588. *q='\0';
  589. printf("\nthe destuffed character string is");
  590. printf("\n%s\n",destuff);
  591. return 0;
  592. }
  593.  
  594.  
  595. ********************************************************************************
  596. SLIDING WINDOW(NO CLIENT SERVER)
  597.  
  598. ***********************/* SIMULATION OF SLIDING WINDOW*/************************
  599.  
  600. #include<stdio.h>
  601. #include<conio.h>
  602. void main()
  603. {
  604. char sender[50],receiver[50];
  605. int i,winsize;
  606. clrscr();
  607. printf("\n ENTER THE WINDOWS SIZE : ");
  608. scanf("%d",&winsize);
  609. printf("\n SENDER WINDOW IS EXPANDED TO STORE MESSAGE OR WINDOW \n");
  610. printf("\n ENTER THE DATA TO BE SENT: ");
  611. fflush(stdin);
  612. gets(sender);
  613. for(i=0;i<winsize;i++)
  614. receiver[i]=sender[i];
  615. receiver[i]=NULL;
  616. printf("\n MESSAGE SEND BY THE SENDER:\n");
  617. puts(sender);
  618. printf("\n WINDOW SIZE OF RECEIVER IS EXPANDED\n");
  619. printf("\n ACKNOWLEDGEMENT FROM RECEIVER \n");
  620. for(i=0;i<winsize;i++);
  621. printf("\n ACK:%d",i);
  622. printf("\n MESSAGE RECEIVED BY RECEIVER IS : ");
  623. puts(receiver);
  624. printf("\n WINDOW SIZE OF RECEIVER IS SHRINKED \n");
  625. getch();
  626. }
  627. ********************************************************************************
  628. //CHAT APPLICATION USING TCP
  629.  
  630.  
  631. Client Program:
  632.  
  633. //Client Program
  634. #include<stdio.h>
  635. #include<sys/types.h>
  636. #include<sys/socket.h>
  637. #include<netinet/in.h>
  638. #include<netdb.h>
  639. #define SERV_TCP_PORT 5035
  640. int main(int argc,char*argv[])
  641. {
  642. int sockfd;
  643. struct sockaddr_in serv_addr;
  644. struct hostent *server;
  645. char buffer[4096];
  646. int k=5,cnt=0;
  647. sockfd=socket(AF_INET,SOCK_STREAM,0);
  648. serv_addr.sin_family=AF_INET;
  649. serv_addr.sin_addr.s_addr=inet_addr("127.0.0.1");
  650. serv_addr.sin_port=htons(SERV_TCP_PORT);
  651. printf("\nReady for sending...");
  652. connect(sockfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr));
  653. printf("\nEnter the message to send\n");
  654. printf("\nClient: ");
  655. fgets(buffer,4096,stdin);
  656. write(sockfd,buffer,4096);
  657. printf("Serverecho:%s",buffer);
  658. printf("\n");
  659. close(sockfd);
  660. return 0;
  661. }
  662.  
  663. Server Program:
  664.  
  665.  
  666. // Server Program
  667. #include<stdio.h>
  668. #include<netinet/in.h>
  669. #include<netdb.h>
  670. #include<string.h>
  671. #define SERV_TCP_PORT 5035
  672. int main(int argc,char**argv)
  673. {
  674. int sockfd,newsockfd,clength;
  675. struct sockaddr_in serv_addr,cli_addr;
  676. char buffer[4096];
  677. //creating a socket
  678. sockfd=socket(AF_INET,SOCK_STREAM,0);
  679. serv_addr.sin_family=AF_INET;
  680. serv_addr.sin_addr.s_addr=INADDR_ANY;
  681. serv_addr.sin_port=htons(SERV_TCP_PORT);
  682. printf("\nStart");
  683. //bind the socket to port address and any local interface
  684. bind(sockfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr));
  685. printf("\nListening...");
  686. printf("\n");
  687. listen(sockfd,5);
  688. clength=sizeof(cli_addr);
  689. newsockfd=accept(sockfd,(struct sockaddr*)&cli_addr,&clength);
  690. //newsockfd=accept(sockfd,(struct sockaddr*)NULL,NULL);
  691. printf("\nAccepted");
  692. printf("\n");
  693. bzero(buffer,4096);
  694. read(newsockfd,buffer,4096);
  695. printf("\nClient message:%s",buffer);
  696. write(newsockfd,buffer,strlen(buffer)+1);
  697. printf("\n");
  698. //close(sockfd);
  699. //return 0;
  700. }
  701. ********************************************************************************
  702.  
  703. AIM: To write a program for UDP echo client server.
  704. CODE :
  705. SERVER:
  706.  
  707. #include<sys/types.h>
  708. #include<sys/socket.h>
  709. #include<netinet/in.h>
  710. #include<unistd.h>
  711. #include<netdb.h>
  712. #include<stdio.h>
  713. #include<string.h>
  714. #include<arpa/inet.h>
  715. #define MAXLINE 1024
  716. int main(int argc,char **argv)
  717. {
  718. int sockfd;
  719. int n;
  720. socklen_t len;
  721. char msg[1024];
  722. struct sockaddr_in servaddr,cliaddr;
  723. sockfd=socket(AF_INET,SOCK_DGRAM,0);
  724. bzero(&servaddr,sizeof(servaddr));
  725. servaddr.sin_family=AF_INET;
  726. servaddr.sin_addr.s_addr=INADDR_ANY;
  727. servaddr.sin_port=htons(5035);
  728. printf("\n\n Binded");
  729. bind(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
  730. printf("\n\n Listening...");
  731. for(;;)
  732. {
  733. printf("\n ");
  734. len=sizeof(cliaddr);
  735. n=recvfrom(sockfd,msg,MAXLINE,0,(struct
  736. sockaddr*)&cliaddr,&len);
  737. printf("\n Client's Message : %s\n",msg);
  738. if(n<6)
  739. perror("send error");
  740. sendto(sockfd,msg,n,0,(struct sockaddr*)&cliaddr,len);
  741. }
  742. return 0;
  743. }
  744.  
  745. CLIENT:
  746.  
  747. #include<sys/types.h>
  748. #include<sys/socket.h>
  749. #include<netinet/in.h>
  750. #include<string.h>
  751. #include<arpa/inet.h>#include<string.h>
  752. #include<arpa/inet.h>
  753. #include<stdio.h>
  754. #define MAXLINE 1024
  755. int main(int argc,char* argv[])
  756. {
  757. int sockfd;
  758. int n;
  759. socklen_t len;
  760. char sendline[1024],recvline[1024];
  761. struct sockaddr_in servaddr;
  762. strcpy(sendline,"");
  763. printf("\n Enter the message : ");
  764. scanf("%s",sendline);
  765. sockfd=socket(AF_INET,SOCK_DGRAM,0);
  766. bzero(&servaddr,sizeof(servaddr));
  767. servaddr.sin_family=AF_INET;
  768. servaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
  769. servaddr.sin_port=htons(5035);
  770. connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
  771. len=sizeof(servaddr);
  772. sendto(sockfd,sendline,MAXLINE,0,(struct sockaddr*)&servaddr,len);
  773. n=recvfrom(sockfd,recvline,MAXLINE,0,NULL,NULL);
  774. recvline[n]=0;
  775. printf("\n Server's Echo : %s\n\n",recvline);
  776. return 0;
  777. }
  778. ********************************************************************************
  779. Aim: To Implement a message transfer from client to server
  780. process using UDP.
  781.  
  782. Server:
  783.  
  784. #include <arpa/inet.h>
  785. #include <netinet/in.h>
  786. #include <stdio.h>
  787. #include <sys/types.h>
  788. #include <sys/socket.h>
  789. #include <unistd.h>
  790. #include <stdlib.h>
  791. #include <string.h>
  792. #define BUFLEN 512
  793. #define PORT 9930
  794. void err(char *str)
  795. {
  796. perror(str);
  797. exit(1);
  798. }
  799. int main(void)
  800. {
  801. struct sockaddr_in my_addr, cli_addr;
  802. int sockfd, i;
  803. socklen_t slen=sizeof(cli_addr);
  804. char buf[BUFLEN];
  805. if ((sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
  806. err("socket");
  807. else
  808. printf("Server : Socket() successful\n");
  809. bzero(&my_addr, sizeof(my_addr));
  810. my_addr.sin_family = AF_INET;
  811. my_addr.sin_port = htons(PORT);
  812. my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  813. if (bind(sockfd, (struct sockaddr* ) &my_addr, sizeof(my_addr))==-1)
  814. err("bind");
  815. else
  816. printf("Server : bind() successful\n");
  817. while(1)
  818. {
  819. if (recvfrom(sockfd, buf, BUFLEN, 0, (struct sockaddr*)&cli_addr,
  820. &slen)==-1)
  821. err("recvfrom()");
  822. printf("Received packet from %s:%d\nData: %s\n\n",
  823. inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port), buf);
  824. }
  825. close(sockfd);
  826. return 0;
  827. }
  828.  
  829.  
  830. Client:
  831.  
  832. #include <arpa/inet.h>
  833. #include <netinet/in.h>
  834. #include <stdio.h>
  835. #include <sys/types.h>
  836. #include <sys/socket.h>
  837. #include <unistd.h>
  838. #include <stdlib.h>
  839. #include <string.h>
  840. #define BUFLEN 512
  841. #define PORT 9930
  842. void err(char *s)
  843. {
  844. perror(s);
  845. exit(1);
  846. }
  847. int main(int argc, char** argv)
  848. {
  849. struct sockaddr_in serv_addr;
  850. int sockfd, i, slen=sizeof(serv_addr);
  851. char buf[BUFLEN];
  852. if(argc != 2)
  853. {
  854. printf("Usage : %s <Server-IP>\n",argv[0]);
  855. exit(0);
  856. }
  857. if ((sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
  858. err("socket");
  859. bzero(&serv_addr, sizeof(serv_addr));
  860. serv_addr.sin_family = AF_INET;
  861. serv_addr.sin_port = htons(PORT);
  862. if (inet_aton(argv[1], &serv_addr.sin_addr)==0)
  863. {
  864. fprintf(stderr, "inet_aton() failed\n");
  865. exit(1);
  866. }
  867. while(1)
  868. {
  869. printf("\nEnter data to send(Type exit and press enter to exit) : ");
  870. scanf("%[^\n]",buf);
  871. getchar();
  872. if(strcmp(buf,"exit") == 0)
  873. exit(0);
  874. if (sendto(sockfd, buf, BUFLEN, 0, (struct sockaddr*)&serv_addr,
  875. slen)==-1)
  876. err("sendto()");
  877. }
  878. close(sockfd);
  879. return 0;
  880. }
  881. *******************************************************************************
  882.  
  883. PROGRAM:TRANSFER A FILE USING TCP**************************/
  884.  
  885. #include<stdio.h>
  886. #include<sys/types.h>
  887. #include<sys/socket.h>
  888. #include<netinet/in.h>
  889. #include<arpa/inet.h>
  890. #include<fcntl.h>
  891. #include<string.h>
  892. main()
  893. {
  894. struct sockaddr_in clientaddr,serveraddr;
  895. int serversock,newserversock,clientsize,n,f,rc;
  896. char filename[100],filedata[300];
  897. fflush(stdin);
  898. serversock=socket(AF_INET,SOCK_STREAM,0);
  899. bzero((char*)&serveraddr,sizeof(serveraddr));
  900. serveraddr.sin_family=AF_INET;
  901. serveraddr.sin_port=2000;
  902. serveraddr.sin_addr.s_addr=inet_addr("127.0.0.1");
  903. bind(serversock,(struct sockaddr*)&serveraddr,sizeof(serveraddr));
  904. sizeof(serveraddr);
  905. listen(serversock,5);
  906. while(1)
  907. {
  908. clientsize=sizeof(clientaddr);
  909. newserversock=accept(serversock,(struct sockaddr*)&clientaddr,&clientsize);
  910. n=read(newserversock,filename,100);
  911. filename[n]=0;
  912. printf("\nThe requested file from the client is %s.\n",filename);
  913. //write(1,filename,n);
  914. f=open(filename,O_RDWR);
  915. n=read(f,filedata,300);
  916. printf("\nThe contents of the file: \n\n");
  917. printf("%s",filedata);
  918. write(newserversock,filedata,n);
  919. }
  920. close(serversock);
  921. close(newserversock);
  922. }
  923. Client:
  924. #include<stdio.h>
  925. #include<sys/types.h>
  926. #include<sys/stat.h>
  927. #include<sys/socket.h>
  928. #include<netinet/in.h>
  929. #include<arpa/inet.h>
  930. #include<fcntl.h>
  931. #include<string.h>
  932. #include<netdb.h>
  933. #include<stdlib.h>
  934. main()
  935. {
  936. struct sockaddr_in serveraddr;
  937. int clientsock,n,rdret,length;
  938. char filename[20],filedata[300];
  939. bzero((char*)&serveraddr,sizeof(serveraddr));
  940. serveraddr.sin_family=AF_INET;
  941. serveraddr.sin_port=2000;
  942. serveraddr.sin_addr.s_addr=inet_addr("127.0.0.1");
  943. clientsock=socket(AF_INET,SOCK_STREAM,0);
  944. if(connect(clientsock,(struct sockaddr*)&serveraddr,sizeof(serveraddr))<0)
  945. {
  946. printf("\nError:Cannot connect...");
  947. exit(0);
  948. }
  949. printf("Enter the name of the file : ");
  950. scanf("%s",filename);
  951. length=strlen(filename);
  952. write(clientsock,filename,length);
  953. rdret=read(clientsock,filedata,300);
  954. printf("\nThe contents of the file: \n\n");
  955. printf("%s",filedata);
  956. close(clientsock);
  957. }
  958.  
  959. ******************************************************************************
  960. 9.username password
  961.  
  962. #include <stdio.h>
  963. #include <stdlib.h>
  964. #include <unistd.h>
  965. #include <errno.h>
  966. #include <string.h>
  967. #include <netdb.h>
  968. #include <sys/types.h>
  969. #include <netinet/in.h>
  970. #include <sys/socket.h>
  971. #include <arpa/inet.h>
  972. int main(int argc, char *argv[])
  973. {
  974. int sock_des,port,n1,n2,s1,s2;
  975. char buffer1[100],buffer2[100],buffer3[100],buffer4[100];
  976. int length,new_des;
  977. struct sockaddr_in server_addr,client_addr;
  978. bzero(buffer3,sizeof(buffer3));
  979. printf("\n Input Authentic Username :\n");
  980. scanf("%s",buffer3);
  981. bzero(buffer4,sizeof(buffer4));
  982. printf("\n Input Authentic Password :\n");
  983. scanf("%s",buffer4);
  984. if(argc!=2)
  985. {
  986. printf("Usage: ./server port\n");
  987. exit(1);
  988. }
  989. port= atoi(argv[1]);
  990. if((sock_des=socket(AF_INET,SOCK_STREAM,0))==-1)
  991. {
  992. perror("socket");
  993. exit(1);
  994. }
  995. server_addr.sin_family = AF_INET;
  996. server_addr.sin_port = htons(port);
  997. server_addr.sin_addr.s_addr= htonl(INADDR_ANY);
  998. if (bind(sock_des,(const struct sockaddr *)&server_addr,sizeof(struct sockaddr))==-1)
  999. {
  1000. perror("bind");
  1001. exit(1);
  1002. }
  1003. if( listen(sock_des,5)==-1)
  1004. {
  1005. perror("listen");
  1006. exit(1);
  1007. }
  1008. printf("Server is listening at port %d \n", port);
  1009. while(1)
  1010. {
  1011. if((new_des=accept(sock_des,(struct sockaddr *)&client_addr,&length))==-1)
  1012. {
  1013. perror("accept");
  1014. exit(1);
  1015. }
  1016. bzero(buffer1,sizeof(buffer1));
  1017. n1=read(new_des,buffer1,sizeof(buffer1));
  1018. buffer1[n1]='\0';
  1019. if((s1=strcmp(buffer1,buffer3))==0)
  1020. {
  1021. write(new_des,"Username Match!Enter Password",30);
  1022. printf("Username Match !!!\n");
  1023. bzero(buffer2,sizeof(buffer2));
  1024. n2=read(new_des,buffer2,sizeof(buffer2));
  1025. buffer2[n2]='\0';
  1026. if((s2=strcmp(buffer2,buffer4))==0)
  1027. {
  1028. write(new_des,"Password Match",15);
  1029. printf("Password Match !!!\n");
  1030. }
  1031. else
  1032. {
  1033. write(new_des,"Password NOT Match",19);
  1034. printf("Password NOT Match !!!\n");
  1035. }
  1036. }
  1037. else
  1038. {
  1039. write(new_des,"Username Not Match",19);
  1040. printf("Username Not Match !!!\n");
  1041. }
  1042. close(new_des);
  1043. }
  1044. }
  1045.  
  1046. client
  1047.  
  1048. #include <stdio.h>
  1049. #include <stdlib.h>
  1050. #include <unistd.h>
  1051. #include <errno.h>
  1052. #include <string.h>
  1053. #include <netdb.h>
  1054. #include <sys/types.h>
  1055. #include <netinet/in.h>
  1056. #include <sys/socket.h>
  1057. #include <arpa/inet.h>
  1058. int main(int argc,char *argv[])
  1059. {
  1060. int sock_des,port,n;
  1061. struct hostent *host;
  1062. char buffer1[100],buffer2[100],buffer3[100],buffer4[100];
  1063. struct sockaddr_in server_addr;
  1064. if(argc!=3)
  1065. {
  1066. printf("Usage: ./client hostname port\n");
  1067. exit(1);
  1068. }
  1069. if((host=gethostbyname(argv[1]))==NULL)
  1070. {
  1071. printf("Unknown Host\n");
  1072. exit(1);
  1073. }
  1074. port = atoi(argv[2]);
  1075. if((sock_des=socket(AF_INET,SOCK_STREAM,0))==-1)
  1076. {
  1077. perror("socket");
  1078. exit(1);
  1079. }
  1080. server_addr.sin_family = AF_INET;
  1081. server_addr.sin_port = htons(port);
  1082. server_addr.sin_addr = *((struct in_addr *)host->h_addr);
  1083. if(connect(sock_des,(struct sockaddr *)&server_addr,sizeof(struct sockaddr))==-1)
  1084. {
  1085. perror("connect");
  1086. exit(1);
  1087. }
  1088. bzero(buffer1,sizeof(buffer1));
  1089. printf("Enter the Username :\n");
  1090. scanf("%s",buffer1);
  1091. write(sock_des,buffer1,sizeof(buffer1));
  1092. bzero(buffer4,sizeof(buffer4));
  1093. n=read(sock_des,buffer4,sizeof(buffer4));
  1094. buffer4[n]='\0';
  1095. printf("Server Sent : %s\n", buffer4);
  1096. bzero(buffer2,sizeof(buffer2));
  1097. printf("Enter the Password :\n");
  1098. scanf("%s",buffer2);
  1099. write(sock_des,buffer2,sizeof(buffer2));
  1100. bzero(buffer3,sizeof(buffer3));
  1101. n=read(sock_des,buffer3,sizeof(buffer3));
  1102. buffer3[n]='\0';
  1103. printf("Server Sent : %s\n", buffer3);
  1104. close(sock_des);
  1105. }
  1106. *******************************************************************************
  1107.  
  1108. /*************************PROGRAM:NR/NRZ**************************************/
  1109.  
  1110.  
  1111. # include <graphics.h>
  1112. # include <iostream.h>
  1113. # include <conio.h>
  1114. # include <string.h>
  1115. # include <dos.h>
  1116.  
  1117. int main(void)
  1118. {
  1119. void drawgrid(int, int, int, int);
  1120. void encode(char *,char *, int, int, int, int);
  1121. void draw(int ,int ,char *, int);
  1122.  
  1123. char *message;
  1124. int len;
  1125.  
  1126. clrscr();
  1127. cout << "
  1128. DIGITAL ENCODING TECHNIQUES";
  1129. cout << "
  1130.  
  1131.  
  1132. Enter the data to be encoded (max 24 bits) : ";
  1133.  
  1134. do{
  1135. cin >> message;
  1136. len = strlen(message);
  1137. if(len>24)
  1138. cout << "Message is greater than 12 bits, please type new message:
  1139. ";
  1140. }while(len>24);
  1141.  
  1142. char *o_mess =new char[len];
  1143. char *e_mess =new char[len*2];
  1144. strcpy(o_mess,message);
  1145.  
  1146. int gd=DETECT, gm, i, x, y;
  1147.  
  1148. initgraph(&gd,&gm,"..\BGI");
  1149. setcolor(8);
  1150. settextstyle(DEFAULT_FONT,0,2);
  1151. outtextxy(100,10,"DIGITAL ENCODING TECHNIQUES");
  1152. setcolor(YELLOW);
  1153. rectangle(0,30,630,450);
  1154. rectangle(1,31,629,449);
  1155. setcolor(WHITE);
  1156. settextstyle(DEFAULT_FONT,0,0);
  1157. drawgrid(120,60,len,20);
  1158. outtextxy(10,50, "Message");
  1159.  
  1160. x= 137;
  1161. for(i=0; i<len; i++, x+=20)
  1162. {
  1163. if(o_mess[i]=='1')
  1164. outtextxy(x,50,"1");
  1165. else
  1166. outtextxy(x,50,"0");
  1167. }
  1168.  
  1169. x=120;
  1170. y=80;
  1171. outtextxy(10,100, "NRZ - L");
  1172. encode(o_mess,e_mess,len,0,2,0);
  1173. draw(x,y,e_mess,len*2);
  1174. y+=60;
  1175.  
  1176. outtextxy(10,160, "NRZ - I");
  1177. encode(o_mess,e_mess,len,3,4,0);
  1178. draw(x,y,e_mess,len*2);
  1179. y+=60;
  1180.  
  1181. outtextxy(10,220, "Bipolar AMI");
  1182. encode(o_mess,e_mess,len,3,1,0);
  1183. draw(x,y,e_mess,len*2);
  1184. y+=60;
  1185.  
  1186. outtextxy(10,280, "Pseudo Tenary");
  1187. encode(o_mess,e_mess,len,4,3,0);
  1188. draw(x,y,e_mess,len*2);
  1189. y+=60;
  1190.  
  1191. outtextxy(10,340, "Manchester");
  1192. encode(o_mess,e_mess,len,0,2,1);
  1193. draw(x,y,e_mess,len*2);
  1194. y+=60;
  1195.  
  1196. outtextxy(10,400, "D-Manchester");
  1197. encode(o_mess,e_mess,len,4,3,1);
  1198. draw(x,y,e_mess,len*2);
  1199. y+=60;
  1200.  
  1201. getch();
  1202. closegraph();
  1203.  
  1204. return 0;
  1205. }
  1206.  
  1207. void drawgrid(int x, int y, int pulses, int width)
  1208. {
  1209. line(x,y,x+(pulses*width),y);
  1210. line(x,y,x,y+(width*12+150));
  1211.  
  1212. for(int i=0; i<pulses; i++)
  1213. {
  1214. setcolor(LIGHTBLUE);
  1215. line(x+width,y+1,x+width,y+(width*12+150));
  1216. setcolor(BLUE);
  1217. line(x+width/2,y+1,x+width/2,y+(width*12+150));
  1218. x+=width;
  1219. }
  1220. setcolor(WHITE);
  1221.  
  1222. return;
  1223. }
  1224.  
  1225. void draw(int x, int y, char *data, int len)
  1226. {
  1227. int prev_y, curr_y;
  1228.  
  1229. prev_y = y;
  1230.  
  1231. for(int i=0; i<len; i++, x+=10)
  1232. {
  1233. if(data[i]=='2')
  1234. curr_y = y;
  1235. if(data[i]=='1')
  1236. curr_y = y+20;
  1237. if(data[i]=='0')
  1238. curr_y = y+40;
  1239.  
  1240.  
  1241. line(x,curr_y,x+10,curr_y);
  1242. sound(70);
  1243. delay(50);
  1244. nosound();
  1245.  
  1246. if(prev_y != curr_y)
  1247. line(x,prev_y,x,curr_y);
  1248. sound(170);
  1249. delay(50);
  1250. nosound();
  1251.  
  1252. prev_y = curr_y;
  1253. delay(10);
  1254. }
  1255. return;
  1256. }
  1257.  
  1258. void encode(char *o_mess,char *e_mess,int len,int one,int zero, int
  1259. mid)
  1260. {
  1261. int i, j, previous=2;
  1262.  
  1263. for(i=0, j=0; i<len; i++, j+=2)
  1264. {
  1265. if(o_mess[i]=='1')
  1266. {
  1267. if(one==0)
  1268. e_mess[j]='0';
  1269. if(one==1)
  1270. e_mess[j]='1';
  1271. if(one==2)
  1272. e_mess[j]='2';
  1273. if(one==3)
  1274. {
  1275. if(previous==2)
  1276. {
  1277. previous=0;
  1278. e_mess[j]='0';
  1279. }
  1280. else
  1281. {
  1282. previous=2;
  1283. e_mess[j]='2';
  1284. }
  1285. }
  1286. if(one==4)
  1287. {
  1288. if(previous==2)
  1289. e_mess[j]='2';
  1290. else
  1291. e_mess[j]='0';
  1292. }
  1293. }
  1294. else
  1295. {
  1296. if(zero==0)
  1297. e_mess[j]='0';
  1298. if(zero==1)
  1299. e_mess[j]='1';
  1300. if(zero==2)
  1301. e_mess[j]='2';
  1302. if(zero==3)
  1303. {
  1304. if(previous==2)
  1305. {
  1306. previous=0;
  1307. e_mess[j]='0';
  1308. }
  1309. else
  1310. {
  1311. previous=2;
  1312. e_mess[j]='2';
  1313. }
  1314. }
  1315. if(zero==4)
  1316. {
  1317. if(previous==2)
  1318. e_mess[j]='2';
  1319. else
  1320. e_mess[j]='0';
  1321. }
  1322. }
  1323. if(mid==1)
  1324. {
  1325. if(e_mess[j]=='2')
  1326. e_mess[j+1]='0';
  1327. else
  1328. e_mess[j+1]='2';
  1329. if(previous==2)
  1330. previous=0;
  1331. else
  1332. previous=2;
  1333. }
  1334. else
  1335. e_mess[j+1]=e_mess[j];
  1336. }
  1337. return;
  1338. }
  1339.  
  1340. *******************************************************************************
  1341. goback narq
  1342.  
  1343. #include<stdio.h>
  1344. #include<math.h>
  1345.  
  1346. int main()
  1347. {
  1348. printf("\t\tGO BACK NARQ\n\n");
  1349. printf("enter the msg signal:-");
  1350. char msg[100];
  1351. int wln;
  1352. scanf("%s",msg);
  1353.  
  1354. printf("\n\nenter the window length:-");
  1355. scanf("%d",&wln);
  1356.  
  1357. int msg_lost=-1,ack_lost=-1,error_frame=-1,i,m,sf=0,sl=0,flag=0;
  1358.  
  1359. printf("\n\nenter the lost msg index:-");
  1360. scanf("%d",&msg_lost);
  1361.  
  1362. for(i=0;msg[i]!='\0';i++)
  1363. {
  1364.  
  1365. printf("\nsendmsgbit(%d)\t",i);
  1366.  
  1367. if(i!=msg_lost)
  1368. {
  1369. if(flag!=5)
  1370. printf("recievedmsgbit(%d)\tmessagebit(%c)",i,msg[i]);
  1371. else
  1372. printf("packet discarded since %d is not received..",m);
  1373.  
  1374. if((flag==5&&sf==m+wln-1)||(flag==5&&msg[i+1]=='\0'))
  1375. {
  1376. i=m-1;
  1377. flag=0;
  1378. printf("\nresending this window again...\n");
  1379. continue;
  1380. }
  1381.  
  1382. sf++;
  1383. if(sf-sl>wln-1)
  1384. sl++;
  1385. }
  1386. else
  1387. {
  1388. printf("lost msgbit....\t");
  1389. m=msg_lost;
  1390. msg_lost=-1;
  1391. flag=5;
  1392. }
  1393.  
  1394. printf("\n");
  1395. }
  1396.  
  1397. }
  1398. ********************************************************************************
  1399. selective repeat arq
  1400. client
  1401. #include<stdio.h>
  1402. #include<sys/types.h>
  1403. #include<sys/socket.h>
  1404. #include<netinet/in.h>
  1405. #include<string.h>
  1406. #include<time.h>
  1407. #include<stdlib.h>
  1408. #include<ctype.h>
  1409. #include<arpa/inet.h>
  1410.  
  1411. #define W 5
  1412. #define P1 50
  1413. #define P2 10
  1414.  
  1415. char a[10];
  1416. char b[10];
  1417. void alpha9(int);
  1418. void alp(int);
  1419.  
  1420. int main()
  1421. {
  1422. struct sockaddr_in ser,cli;
  1423. int s,n,sock,i,j,c=1,f;
  1424. unsigned int s1;
  1425. s=socket(AF_INET,SOCK_STREAM,0);
  1426. ser.sin_family=AF_INET;
  1427. ser.sin_port=6500;
  1428. ser.sin_addr.s_addr=inet_addr("127.0.0.1");
  1429. bind(s,(struct sockaddr *) &ser, sizeof(ser));
  1430. listen(s,1);
  1431. n=sizeof(cli);
  1432. sock=accept(s,(struct sockaddr *)&cli, &n);
  1433. printf("\nTCP Connection Established.\n");
  1434. s1=(unsigned int) time(NULL);
  1435. srand(s1);
  1436. strcpy(b,"Time Out ");
  1437. recv(sock,a,sizeof(a),0);
  1438. f=atoi(a);
  1439. while(1)
  1440. {
  1441. for(i=0;i<W;i++)
  1442. {
  1443. recv(sock,a,sizeof(a),0);
  1444. if(strcmp(a,b)==0)
  1445. {
  1446. break;
  1447. }
  1448. }
  1449. i=0;
  1450. while(i<W)
  1451. {
  1452. L:
  1453. j=rand()%P1;
  1454. if(j<P2)
  1455. {
  1456. alp(c);
  1457. send(sock,b,sizeof(b),0);
  1458. goto L;
  1459. }
  1460. else
  1461. {
  1462. alpha9(c);
  1463. if(c<=f)
  1464. {
  1465. printf("\nFrame %s Received ",a);
  1466. send(sock,a,sizeof(a),0);
  1467. }
  1468. else
  1469. {
  1470. break;
  1471. }
  1472. c++;
  1473. }
  1474. if(c>f)
  1475. {
  1476. break;
  1477. }
  1478. i++;
  1479. }
  1480. }
  1481. close(sock);
  1482. close(s);
  1483. return 0;
  1484. }
  1485.  
  1486. void alpha9(int z)
  1487. {
  1488. int k,i=0,j,g;
  1489. k=z;
  1490. while(k>0)
  1491. {
  1492. i++;
  1493. k=k/10;
  1494. }
  1495. g=i;
  1496. i--;
  1497. while(z>0)
  1498. {
  1499. k=z%10;
  1500. a[i]=k+48;
  1501. i--;
  1502. z=z/10;
  1503. }
  1504. a[g]='\0';
  1505. }
  1506.  
  1507. void alp(int z)
  1508. {
  1509. int k,i=1,j,g;
  1510. k=z;
  1511. b[0]='N';
  1512. while(k>0)
  1513. {
  1514. i++;
  1515. k=k/10;
  1516. }
  1517. g=i;
  1518. i--;
  1519. while(z>0)
  1520. {
  1521. k=z%10;
  1522. b[i]=k+48;
  1523. i--;
  1524. z=z/10;
  1525. }
  1526. b[g]='\0';
  1527. }
  1528.  
  1529. server
  1530. #include<stdio.h>
  1531. #include<sys/types.h>
  1532. #include<sys/socket.h>
  1533. #include<netinet/in.h>
  1534. #include<string.h>
  1535. #include<time.h>
  1536. #include<stdlib.h>
  1537. #include<ctype.h>
  1538.  
  1539. #define W 5
  1540.  
  1541. char a[10];
  1542. char b[10];
  1543. void alpha9(int);
  1544. int con();
  1545.  
  1546. int main()
  1547. {
  1548. int s,f,wl,c=1,x,i=0,j,n,p=0,e=0;
  1549. struct sockaddr_in ser;
  1550. s=socket(AF_INET,SOCK_STREAM,0);
  1551. ser.sin_family=AF_INET;
  1552. ser.sin_port=6500;
  1553. ser.sin_addr.s_addr=inet_addr("127.0.0.1");
  1554. connect(s,(struct sockaddr *) &ser, sizeof(ser));
  1555. printf("\nTCP Connection Established.\n");
  1556. printf("\nEnter the number of Frames: ");
  1557. scanf("%d",&f);
  1558. alpha9(f);
  1559. send(s,a,sizeof(a),0);
  1560. strcpy(b,"Time Out ");
  1561. while(1)
  1562. {
  1563. for(i=0;i<W;i++)
  1564. {
  1565. alpha9(c);
  1566. send(s,a,sizeof(a),0);
  1567. if(c<=f)
  1568. {
  1569. printf("\nFrame %d Sent",c);
  1570. c++;
  1571. }
  1572. }
  1573. i=0;
  1574. wl=W;
  1575. while(i<W)
  1576. {
  1577. recv(s,a,sizeof(a),0);
  1578. p=atoi(a);
  1579. if(a[0]=='N')
  1580. {
  1581. e=con();
  1582. if(e<f)
  1583. {
  1584. printf("\nNAK %d",e);
  1585. printf("\nFrame %d sent",e);
  1586. i--;
  1587. }
  1588. }
  1589. else
  1590. {
  1591. if(p<=f)
  1592. {
  1593. printf("\nFrame %s Acknowledged",a);
  1594. wl--;
  1595. }
  1596. else
  1597. {
  1598. break;
  1599. }
  1600. }
  1601. if(p>f)
  1602. {
  1603. break;
  1604. }
  1605. i++;
  1606. }
  1607. if(wl==0 && c>f)
  1608. {
  1609. send(s,b,sizeof(b),0);
  1610. break;
  1611. }
  1612. else
  1613. {
  1614. c=c-wl;
  1615. wl=W;
  1616. }
  1617. }
  1618. close(s);
  1619. return 0;
  1620. }
  1621.  
  1622. void alpha9(int z)
  1623. {
  1624. int k,i=0,j,g;
  1625. k=z;
  1626. while(k>0)
  1627. {
  1628. i++;
  1629. k=k/10;
  1630. }
  1631. g=i;
  1632. i--;
  1633. while(z>0)
  1634. {
  1635. k=z%10;
  1636. a[i]=k+48;
  1637. i--;
  1638. z=z/10;
  1639. }
  1640. a[g]='\0';
  1641. }
  1642.  
  1643. int con()
  1644. {
  1645. char k[9];
  1646. int i=1;
  1647. while(a[i]!='\0')
  1648. {
  1649. k[i-1]=a[i];
  1650. i++;
  1651. }
  1652. k[i-1]='\0';
  1653. i=atoi(k);
  1654. return i;
  1655. }
  1656. ********************************************************************************
  1657. client server for arithmetic operations
  1658. #include<stdio.h>
  1659. #include<stdlib.h>
  1660. #include<sys/types.h>
  1661. #include<sys/socket.h>
  1662. #include<netinet/in.h>
  1663.  
  1664. int main(int argc,int *argv[])
  1665. {
  1666. int n1=atoi(argv[1]),n2=atoi(argv[2]),res=0;
  1667.  
  1668. char operator=argv[3][0];
  1669. int sock_id=socket(AF_UNIX,SOCK_STREAM,0);
  1670. if(sock_id<0)
  1671. {
  1672. printf("Error in getting socket\n");
  1673. return 0;
  1674. }
  1675.  
  1676. struct sockaddr_in clientstruct;
  1677. clientstruct.sin_family=AF_UNIX;
  1678. clientstruct.sin_addr.s_addr=inet_addr("127.0.0.1");
  1679. clientstruct.sin_port=1025;
  1680.  
  1681. int ret=connect(sock_id,(struct sockaddr *)&clientstruct,sizeof(clientstruct));
  1682.  
  1683.  
  1684. write(sock_id,&n1,sizeof(n1));
  1685. write(sock_id,&n2,sizeof(n2));
  1686. write(sock_id,&operator,sizeof(operator));
  1687.  
  1688. int ret1=read(sock_id,&res,sizeof(res));
  1689. printf("FROM SERVER:%d \n Bytes=%d\n",res,ret1);
  1690. close(sock_id);
  1691.  
  1692.  
  1693.  
  1694. return 0;
  1695. }
  1696.  
  1697.  
  1698. Code for Server
  1699.  
  1700. #include<stdio.h>
  1701. #include<stdlib.h>
  1702. #include<sys/types.h>
  1703. #include<sys/socket.h>
  1704. #include<netinet/in.h>
  1705.  
  1706. int main()
  1707. {
  1708. int n1,n2,res=0;
  1709. char operator;
  1710. int session_id;
  1711. int server_id=socket(AF_UNIX,SOCK_STREAM,0);
  1712. if(server_id<0)
  1713. {
  1714. printf("Error in getting socket\n");
  1715. return 0;
  1716. }
  1717.  
  1718. struct sockaddr_in serverstruct,clientstruct;
  1719. serverstruct.sin_family=AF_UNIX;
  1720. serverstruct.sin_addr.s_addr=inet_addr("127.0.0.1");
  1721. serverstruct.sin_port=1025;
  1722. int i=bind(server_id,(struct sockaddr*)&serverstruct,sizeof(serverstruct));
  1723. if(i<0)
  1724. {
  1725. printf("Error in bind\n");
  1726. return 0;
  1727. }
  1728.  
  1729. i=listen(server_id,10);
  1730. if(i<0)
  1731. {
  1732. printf("Error in listening\n");
  1733. return 0;
  1734. }
  1735. int client_len=sizeof(serverstruct);
  1736. while(1)
  1737. {
  1738. printf("Waiting for the client\n");
  1739. session_id=accept(server_id,(struct sockaddr*)&serverstruct,&client_len);
  1740. read(session_id,&n1,sizeof(n1));
  1741. read(session_id,&n2,sizeof(n2));
  1742. read(session_id,&operator,sizeof(operator));
  1743.  
  1744. switch(operator)
  1745. {
  1746. case '+':
  1747. res=n1+n2;
  1748. break;
  1749. case '-':
  1750. res=n1-n2;
  1751. break;
  1752. case '*':
  1753. res=n1*n2;
  1754. break;
  1755. case '/':
  1756. res=n1/n2;
  1757. break;
  1758. default:
  1759. printf("invalid operation\n");
  1760. }
  1761. printf("From CLIENT:n1=%d\n",n1);
  1762. printf("From CLIENT:n2=%d\n",n2);
  1763. printf("From CLIENT:operator=%c\n",operator);
  1764. int b=write(session_id,&res,sizeof(res));
  1765. close(session_id);
  1766. }
  1767.  
  1768.  
  1769. close(server_id);
  1770. return 0;
  1771. }
  1772. *******************************************************************************
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!