API tools faq
paste
Guest User

Untitled

a guest
Jun 19th, 2018
82
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.12 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <sys/time.h>
  5. #include <sys/types.h>
  6. #include <unistd.h>
  7. #include <sys/select.h>
  8. #include <errno.h>
  9. #include "init.h"
  10.  
  11. #define SIZE 220000
  12.  
  13. int main(int argc, char *argv[])
  14. {
  15. unsigned int ret, accept_desc, n, ssd, c = 1, err;
  16. struct timeval tv;
  17. unsigned char *buf1;
  18. fd_set rfd;
  19.  
  20. ssd = server_listen(argc, argv);
  21. n = ssd;
  22. tv.tv_sec = 0;
  23. tv.tv_usec = 1000;
  24.  
  25. FD_ZERO(&rfd);
  26. FD_SET(ssd, &rfd);
  27. while (1) {
  28. FD_SET(accept_desc, &rfd);
  29. ret = select(n + 1, &rfd, NULL, NULL, NULL);
  30. if (ret < 0) {
  31. err = errno;
  32. perror("Error in selectn");
  33. error(err);
  34. }
  35. if (FD_ISSET(ssd, &rfd)) {
  36. //Accept
  37. accept_desc = server_accept(ssd);
  38. fprintf(stderr, "client %d is connectedn", accept_desc);
  39. if (n < accept_desc)
  40. n = accept_desc;
  41. }
  42. if (FD_ISSET(accept_desc, &rfd)) {
  43. c++;
  44. //Receive
  45. buf1 = receive(accept_desc, c);
  46.  
  47. //Send
  48. send_str(accept_desc, buf1, strlen(buf1) + 1);
  49.  
  50. fprintf(stderr, "sent %ldn", strlen(buf1) + 1);
  51. free(buf1);
  52. }
  53. }
  54. }
  55.  
  56. #include <stdio.h>
  57. #include <stdlib.h>
  58. #include <string.h>
  59. #include <strings.h>
  60. #include <sys/socket.h>
  61. #include <netdb.h> //for Sockaddr and hostent
  62. #include <errno.h>
  63. #include <sys/select.h>
  64. #include <unistd.h>
  65. #include <sys/queue.h>
  66. #include <time.h>
  67. #include <sys/types.h>
  68. #include <netinet/in.h>
  69. #include <netinet/tcp.h>
  70. #include "init.h"
  71.  
  72. #define SIZE 220000
  73.  
  74. int main(int argc, char *argv[])
  75. {
  76. unsigned int err, i = 0 , len = 0, j, k = 1, fd;
  77. struct timeval tv;
  78. unsigned char *buf1, *buf2;
  79. fd_set rfd;
  80.  
  81. fd = client_connect(argc, argv);
  82. tv.tv_sec = 0;
  83. tv.tv_usec = 1000;
  84.  
  85. FD_ZERO(&rfd);
  86. FD_SET(0, &rfd);
  87. FD_SET(fd, &rfd);
  88. while(1) {
  89. FD_SET(0, &rfd);
  90. FD_SET(fd, &rfd);
  91. if ((select(fd + 1, &rfd, NULL, NULL, &tv) < 0)) {
  92. err = errno;
  93. perror("Select error");
  94. error(err);
  95. }
  96.  
  97. if (FD_ISSET(fd, &rfd)) {
  98.  
  99. buf2 = receive(fd, len + 1);
  100.  
  101. if(strcmp(buf1, buf2) == 0){
  102. fprintf(stderr, "Matchn");
  103. } else {
  104. fprintf(stderr, "Unmatch %ld %ldn", strlen(buf1), strlen(buf2));
  105. exit(1);
  106. }
  107. free(buf2);
  108. free(buf1);
  109. k = 1;
  110. }
  111. if(k == 1){
  112. buf1 = malloc(len + 2);
  113. j = 1;
  114. while(j <= i+1){
  115. buf1[j-1] = 'A';
  116. j++;
  117. }
  118. buf1[j-1] = 0;
  119. i++;
  120. len++;
  121. send_str(fd, buf1, strlen(buf1) + 1);
  122. k = 0;
  123.  
  124. }
  125. if(len >= 200000)
  126. exit(1);
  127. }
  128. }
  129.  
  130. #include "init.h"
  131. #include <stdio.h>
  132. #include <sys/socket.h>
  133. #include <sys/types.h>
  134. #include <netinet/in.h>
  135. #include <stdlib.h>
  136. #include <string.h>
  137. #include <unistd.h>
  138. #include <arpa/inet.h>
  139. #include <errno.h>
  140. #include <sys/select.h>
  141. #include <netinet/tcp.h>
  142. #include <netdb.h>
  143. #include <netinet/in.h>
  144. #include <time.h>
  145.  
  146. #define MAX_CLIENT 20000
  147. #define SIZE 220000
  148.  
  149. struct hostent *server;
  150. int count = 0, csd[MAX_CLIENT];
  151.  
  152. void error(int err)
  153. {
  154. fprintf(stderr, "Error No. %dn", err);
  155. exit(err);
  156. }
  157.  
  158. unsigned char *receive(int csd, int size)
  159. {
  160. unsigned int ret, err;
  161. unsigned char *buf = malloc(size), *buf1 = NULL;
  162.  
  163. memset(buf, 0,size);
  164. lp:
  165. ret = recv(csd, buf, size, 0);
  166.  
  167. if(buf[ret-1] > 0) {
  168. buf1 = malloc(size);
  169. strcpy(buf1, buf);
  170. memset(buf, 0, size);
  171. goto lp;
  172. }
  173. if (ret < 0) {
  174. err = errno;
  175. perror("Error in receiven");
  176. error(err);
  177. } else if (ret == 0) {
  178. fprintf(stderr, "client disconnectedn");
  179. close(csd);
  180. } else {
  181. if(buf1 != NULL) {
  182. strcat(buf1, buf);
  183. free(buf);
  184. fprintf(stderr, "buf: %ldn", strlen(buf));
  185. return buf1;
  186. }
  187. return buf;
  188. }
  189.  
  190. }
  191.  
  192. void send_str(int csd, unsigned char *buf, int size)
  193. {
  194. unsigned int ret, err;
  195.  
  196. ret = send(csd, buf, size, 0);
  197. if (ret < 0) {
  198. err = errno;
  199. perror("Error in sendn");
  200. error(err);
  201. } else if(ret == 0)
  202. fprintf(stderr, "Nothing to sendn");
  203. }
  204.  
  205. int server_accept(int ssd)
  206. {
  207. int accept_desc, err;
  208. struct sockaddr_in cli_addr;
  209. socklen_t cli_addr_len;
  210.  
  211. accept_desc = accept(ssd, (struct sockaddr *)&cli_addr,
  212. (socklen_t *)&cli_addr_len);
  213. if (accept_desc < 0) {
  214. err = errno;
  215. perror("Error in acceptn");
  216. error(err);
  217. }
  218.  
  219. return accept_desc;
  220. }
  221.  
  222. int get_option1(int argc, char **argv)
  223. {
  224. int portno = 0, err, opt;
  225.  
  226. while ((opt = getopt(argc, argv, "p:i:")) != -1) {
  227. switch (opt) {
  228. case 'p':
  229. portno = atoi(optarg);
  230. memset(&optarg, 0, strlen(optarg));
  231. break;
  232. case 'i':
  233. server = gethostbyname(optarg);
  234. memset(&optarg, 0, strlen(optarg));
  235. break;
  236.  
  237. default: /* '?' */
  238. err = errno;
  239. fprintf(stderr, "Usage: %sn", argv[0]);
  240. error(err);;
  241. }
  242. }
  243. if (portno == 0) {
  244. fprintf(stderr, "Assign port numbern");
  245. exit(1);
  246. }
  247. printf("portno = %d optind = %dn", portno, optind);
  248.  
  249. return portno;
  250. }
  251.  
  252.  
  253. int client_connect(int argc, char **argv)
  254. {
  255. int fd1, err, ret, flag = 1, portno;
  256. struct sockaddr_in serv_addr;
  257.  
  258. portno = get_option1(argc, argv);
  259.  
  260. if(server == NULL) {
  261. fprintf(stderr, "Assign IPn");
  262. exit(1);
  263. }
  264.  
  265. fd1 = socket(AF_INET, SOCK_STREAM, 0);
  266. //fd1 = socket(AF_INET, SOCK_DGRAM, 0);
  267. if (fd1 == -1) {
  268. err = errno;
  269. perror("ERROR on creating Socketn");
  270. error(err);
  271. }
  272. fprintf(stderr, "%dn", fd1);
  273. fprintf(stderr, "socket created successfully.n");
  274. bzero((char *) &serv_addr, sizeof(serv_addr));
  275. serv_addr.sin_family = AF_INET;
  276. bcopy((char *) server->h_addr, (char *)&serv_addr.sin_addr.s_addr,
  277. server->h_length);
  278. serv_addr.sin_port = htons(portno);
  279. //Setsockopt
  280. ret = setsockopt(fd1, IPPROTO_TCP, TCP_NODELAY,
  281. (char *) &flag, sizeof(int));
  282. if (ret != 0) {
  283. err = errno;
  284. perror("ERROR :");
  285. error(err);
  286. }
  287. //Connect
  288. if (connect(fd1, (struct sockaddr *)&serv_addr,
  289. sizeof(serv_addr)) == -1) {
  290. err = errno;
  291. perror("ERROR in Connecting");
  292. error(err);
  293. }
  294. printf("Client connected Successfullyn");
  295.  
  296. return fd1;
  297. }
  298.  
  299. int server_listen(int argc, char **argv)
  300. {
  301. int ssd, err, flag = 1, ret, portno;
  302. size_t addrlen;
  303. struct sockaddr_in serv_addr;
  304.  
  305. portno = get_option1(argc, argv);
  306. //Socket
  307. ssd = socket(AF_INET, SOCK_STREAM, 0);
  308. //ssd = socket(AF_INET, SOCK_DGRAM, 0);
  309. if (ssd < 0) {
  310. err = errno;
  311. perror("Error in socket");
  312. error(err);
  313. }
  314. //Setsockopt
  315. ret = setsockopt(ssd, IPPROTO_TCP, TCP_NODELAY,
  316. (char *) &flag, sizeof(int));
  317. if (ret != 0) {
  318. err = errno;
  319. perror("ERROR :");
  320. error(err);
  321. }
  322. //Socket family
  323. serv_addr.sin_family = AF_INET;
  324. serv_addr.sin_addr.s_addr = INADDR_ANY;
  325. serv_addr.sin_port = htons(portno);
  326. bzero(&serv_addr.sin_zero, sizeof(serv_addr.sin_zero));
  327. addrlen = sizeof(serv_addr);
  328. //Bind
  329. ret = bind(ssd, (struct sockaddr *)&serv_addr, addrlen);
  330. if (ret < 0) {
  331. err = errno;
  332. perror("Error in binding");
  333. error(err);
  334. }
  335. fprintf(stderr, "Bind completedn");
  336. //Listen
  337. ret = listen(ssd, MAX_CLIENT);
  338. if (ret < 0) {
  339. err = errno;
  340. perror("Error in listen");
  341. error(err);
  342. }
  343. fprintf(stderr, "listenn");
  344.  
  345. return ssd;
  346. }
  347.  
  348. int server_listen(int argc, char **argv);
  349.  
  350. int client_connect(int argc, char **argv);
  351.  
  352. unsigned char *receive(int csd, int size);
  353.  
  354. void send_str(int csd, unsigned char *buf, int size);
  355.  
  356. int server_accept(int ssd);
  357.  
  358. void error(int err);
  359.  
  360. #ifndef INIT_H
  361. #define INIT_H
  362.  
  363. int server_listen(int argc, char **argv);
  364.  
  365. int client_connect(int argc, char **argv);
  366.  
  367. unsigned char *receive(int csd, int size);
  368.  
  369. void send_str(int csd, unsigned char *buf, int size);
  370.  
  371. int server_accept(int ssd);
  372.  
  373. void error(int err);
  374.  
  375. #endif // INIT_H
  376.  
  377. .PHONY: all client server
  378.  
  379. if(buf1 != NULL) {
  380. strcat(buf1, buf);
  381. free(buf);
  382. fprintf(stderr, "buf: %ldn", strlen(buf));
  383. return buf1;
  384. }
  385.  
  386. if(buf[ret-1] > 0) {
  387. buf1 = malloc(size);
  388. strcpy(buf1, buf); // <--
  389. memset(buf, 0, size);
  390. goto lp;
  391. }
  392.  
  393. err = errno;
  394.  
  395. if ((select(fd + 1, &rfd, NULL, NULL, &tv) < 0)) {
  396.  
  397. int client_connect(int argc, char **argv)
  398.  
  399. if (FD_ISSET(fd, &rfd)) {
  400.  
  401. if(k == 1){
  402.  
  403. unsigned char *buf1, *buf2;
  404.  
  405. while(1)
  406.  
  407. while(j <= i+1){
  408. buf1[j-1] = 'A';
  409. j++;
  410. }
  411.  
  412. if(k == 1){
  413. buf1 = malloc(len + 2);
  414. j = 1;
  415. while(j <= i+1){
  416. buf1[j-1] = 'A';
  417. j++;
  418. }
  419. buf1[j-1] = 0;
  420. i++;
  421. len++;
  422. send_str(fd, buf1, strlen(buf1) + 1);
  423. k = 0;
  424. }
  425.  
  426. if(len >= 200000)
  427. exit(1);
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!