SHARE
TWEET

Untitled

a guest Jan 21st, 2020 69 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //serwer
  2.  
  3. #include<sys/types.h>
  4. #include<sys/socket.h>
  5. #include<stdio.h>
  6. #include<netinet/in.h>
  7. #include<arpa/inet.h>
  8. #include<unistd.h>
  9.  
  10. /* A. Mroz - zad. na SK, do modyfikacji */
  11. /* bez pelnej obslugi bledow! */
  12.  
  13. struct my_msg{
  14.     char name[16];
  15.     char text[255];
  16. };
  17.  
  18. int main() {
  19.  
  20.     int sockfd;
  21.     u_short my_port;
  22.     struct sockaddr_in server_addr;
  23.     struct my_msg msg;
  24.  
  25.     /* wybieram "unikalny" numer portu dla serwera */
  26.     my_port = 5000 + (getpid() % 10000);
  27.  
  28.     /* towrze gniazdo - na razie tylko czesc "protokol" */
  29.     sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  30.  
  31.     /* podpinam gniazdo pod  konkretny "adres-lokalny"
  32.        i "proces-lokalny" (= port) */
  33.     server_addr.sin_family      = AF_INET;           /* IPv4 */
  34.     server_addr.sin_addr.s_addr = //inet_addr("158.75.112.121"); //juliusz na sztywno
  35.                                 htonl(INADDR_ANY); /* dowolny (moj) interfejs */
  36.     server_addr.sin_port        = htons(my_port);    /* moj port */
  37.     bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
  38.  
  39.     printf("[Serwer]: Utworzone gniazdo, slucham na porcie: %d\n", my_port);
  40.  
  41.     while(1) {
  42.         recvfrom(sockfd, &msg, sizeof(msg), 0, NULL, NULL);
  43.         printf("Wiadomosc od %s: %s\n", msg.name, msg.text);
  44.     }
  45.  
  46.  
  47.     return 0;
  48.  
  49. }
  50.  
  51. //klient
  52.  
  53. #include<sys/types.h>
  54. #include<sys/socket.h>
  55. #include<stdio.h>
  56. #include<stdlib.h>
  57. #include<netinet/in.h>
  58. #include<arpa/inet.h>
  59. #include<unistd.h>
  60. #include<string.h>
  61.  
  62. /* A. Mroz - zad. na SK, do modyfikacji */
  63. /* bez pelnej obslugi bledow! */
  64.  
  65. struct my_msg{
  66.     char name[16];
  67.     char text[255];
  68. };
  69.  
  70. int main(int argc, char *argv[]) {
  71.  
  72.     int sockfd;
  73.     struct sockaddr_in client_addr, server_addr;
  74.     struct my_msg msg;
  75.     int bindresult;
  76.     ssize_t bytes;
  77.  
  78.     /* przygotowanie adresu serwera */
  79.     server_addr.sin_family      = AF_INET; /* IPv4 */
  80.      /* 1 argument = adres IP serwera */
  81.     server_addr.sin_addr.s_addr = (inet_addr(argv[1]));
  82.      /* 2 argument = port serwera*/
  83.     server_addr.sin_port        = htons((u_short)atoi(argv[2]));  
  84.  
  85.     /* towrze gniazdo - na razie tylko czesc "protokol" */
  86.     sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  87.  
  88.     /* podpinam gniazdo pod  "adres-lokalny"
  89.        i "proces-lokalny" (= port)
  90.        Ten krok mozna pominac (dla sesji bezpolaczenioweji) */
  91.     client_addr.sin_family      = AF_INET;           /* IPv4 */
  92.     client_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* dowolny interfejs */
  93.     client_addr.sin_port        = htons(0);          /* dowolny port */
  94.     bindresult =  bind(sockfd, (struct sockaddr *)&client_addr, sizeof(client_addr));
  95.  
  96.     printf("[Klient]: Tworze gniazdo (%s)\n",
  97.         (bindresult == 0)?"OK":"blad tworzenia gniazda");
  98.  
  99.  
  100.     printf("[Klient]: Podaj swoj nick:\n> ");
  101.     fgets(msg.name, 16, stdin);
  102.     msg.name[strlen(msg.name)-1] = '\0';
  103.     printf("[Klient]: Podaj wiadomosc do serwera:\n> ");
  104.     fgets(msg.text, 255, stdin);
  105.     msg.text[strlen(msg.text)-1] = '\0';
  106.  
  107.    
  108.     printf("[Klient]: wysylam...");
  109.  
  110.     bytes = sendto(sockfd, &msg, sizeof(msg), 0,
  111.                 (struct sockaddr *)&server_addr, sizeof(server_addr));
  112.    
  113.     printf(" (%s: %zd bajtow)\n", (bytes > 0)?"OK":"cos nie tak!", bytes);
  114.  
  115.     close(sockfd);
  116.     return 0;
  117.  
  118. }
  119.  
  120. serwertcp
  121.  
  122. #include<sys/types.h>
  123. #include<sys/socket.h>
  124. #include<stdio.h>
  125. #include<netinet/in.h>
  126. #include<arpa/inet.h>
  127. #include<unistd.h>
  128.  
  129. /* A. Mroz - zadanie na SK, do modyfikacji */
  130. /* bez pelnej obslugi bledow! */
  131.  
  132. #define MY_MSG_SIZE 127
  133.  
  134. int main() {
  135.  
  136.     int sockfd, newsockfd;
  137.     u_short my_port;
  138.     struct sockaddr_in server_addr, client_addr;
  139.     char msg[MY_MSG_SIZE];
  140.     socklen_t clilen;
  141.     int bytes;
  142.     int clientno = 0;
  143.  
  144.     /* wybieram "unikalny" numer portu dla serwera */
  145.     my_port = 5000 + (getpid() % 10000);
  146.  
  147.     /* tworze gniazdo i podpinam adres */
  148.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
  149.     server_addr.sin_family      = AF_INET;           /* IPv4 */
  150.     server_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* dowolny (moj) interfejs */
  151.     server_addr.sin_port        = htons(my_port);    /* moj port */
  152.     bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
  153.  
  154.     printf("[Serwer]: Utworzone gniazdo TCP, slucham na porcie: %d\n", my_port);
  155.  
  156.     listen(sockfd, 5);
  157.  
  158.     while(1) {
  159.         ++clientno;
  160.         clilen = sizeof(client_addr);
  161.         printf("[Serwer]: Czekam na klienta...\n");
  162.         newsockfd = accept(sockfd, (struct sockaddr *)&client_addr, &clilen);
  163.         printf("[Serwer]: Zglosil sie klient nr %d z IP: %s, port: %d\n",
  164.                 clientno, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
  165.         bytes = read(newsockfd, msg, MY_MSG_SIZE);
  166.         msg[bytes] = '\0';
  167.         printf(" Komunikat klienta nr %d: %s\n", clientno, msg);
  168.         close(newsockfd);
  169.     }
  170.  
  171.  
  172.     return 0;
  173.  
  174. }
  175.  
  176. klient tcp
  177.  
  178. #include<sys/types.h>
  179. #include<sys/socket.h>
  180. #include<stdio.h>
  181. #include<stdlib.h>
  182. #include<netinet/in.h>
  183. #include<arpa/inet.h>
  184. #include<unistd.h>
  185. #include<string.h>
  186.  
  187. /* A. Mroz - zadanie na SK, do modyfikacji */
  188. /* bez pelnej obslugi bledow! */
  189.  
  190. #define MY_MSG_SIZE 127
  191.  
  192. int main(int argc, char *argv[]) {
  193.  
  194.     int sockfd;
  195.     struct sockaddr_in server_addr;
  196.     char  msg[MY_MSG_SIZE];
  197.     int connectresult;
  198.     int bytes;
  199.  
  200.     /* przygotowanie adresu serwera */
  201.     server_addr.sin_family      = AF_INET; /* IPv4 */
  202.      /* 1 argument = adres IP serwera */
  203.     server_addr.sin_addr.s_addr = (inet_addr(argv[1]));
  204.      /* 2 argument = port serwera*/
  205.     server_addr.sin_port        = htons((u_short)atoi(argv[2]));  
  206.  
  207.     /* towrze gniazdo - na razie tylko czesc "protokol" */
  208.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
  209.  
  210.     connectresult  =  connect(sockfd,
  211.         (struct sockaddr *)&server_addr, sizeof(server_addr));
  212.  
  213.     printf("[Klient]: Lacze z gniazdem TCP (%s)\n",
  214.         (connectresult == 0)?"OK":"blad polaczenia");
  215.  
  216.  
  217.     printf("[Klient]: Podaj wiadomosc do serwera:\n> ");
  218.     fgets(msg, MY_MSG_SIZE, stdin);
  219.     msg[strlen(msg)-1] = '\0';
  220.  
  221.    
  222.     printf("[Klient]: wysylam...");
  223.  
  224.     bytes = write(sockfd, msg, strlen(msg));
  225.    
  226.     printf(" (%s: %zd bajtow)\n", (bytes > 0)?"OK":"cos nie tak!", bytes);
  227.  
  228.     close(sockfd);
  229.  
  230.     return 0;
  231.  
  232. }
RAW Paste Data
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
Top