开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
connectsock.c
资源名称：3.0-20000220-SNAP.tar.gz　[点击查看]
上传用户：minyiyu
上传日期：2018-12-24
资源大小：864k
文件大小：9k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

connectsock.c：源码内容
  1. #include "innbbsconf.h"
  2. #include "daemon.h"
  4. extern int errno;
  5. static void 
  6. reapchild(s)
  7. int     s;
  8. {
  9. int     state;
  10. while (waitpid(-1, &state, WNOHANG | WUNTRACED) > 0) {
  11. /* printf("reaping childn"); */
  12. }
  13. }
  15. void 
  16. dokill(s)
  17. int     s;
  18. {
  19. kill(0, SIGKILL);
  20. }
  22. static  INETDstart = 0;
  23. int 
  24. startfrominetd(flag)
  25. {
  26. INETDstart = flag;
  27. }
  30. int 
  31. standalonesetup(fd)
  32. int     fd;
  33. {
  34. int     on = 1;
  35. struct linger foobar;
  36. if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &on, sizeof(on)) < 0)
  37. syslog(LOG_ERR, "setsockopt (SO_REUSEADDR): %m");
  38. foobar.l_onoff = 0;
  39. if (setsockopt(fd, SOL_SOCKET, SO_LINGER, (char *) &foobar, sizeof(foobar)) < 0)
  40. syslog(LOG_ERR, "setsockopt (SO_LINGER): %m");
  41. }
  43. static char *UNIX_SERVER_PATH;
  44. static int (*halt) ();
  45. sethaltfunction(haltfunc)
  46. int     (*haltfunc) ();
  47. {
  48. halt = haltfunc;
  49. }
  51. void 
  52. docompletehalt(s)
  53. int     s;
  54. {
  55. /*
  56.  * printf("try to remove %sn", UNIX_SERVER_PATH);
  57.  * unlink(UNIX_SERVER_PATH);
  58.  */
  59. exit(0);
  60. /* dokill(); */
  61. }
  63. void 
  64. doremove(s)
  65. int     s;
  66. {
  67. if (halt != NULL)
  68. (*halt) (s);
  69. else
  70. docompletehalt(s);
  71. }
  74. initunixserver(path, protocol)
  75. char   *path;
  76. char   *protocol;
  77. {
  78. struct sockaddr_un s_un;
  79. /* unix endpoint address */
  80. struct protoent *pe; /* protocol information entry */
  81. int     s;
  82. char   *ptr;
  83. bzero((char *) &s_un, sizeof(s_un));
  84. s_un.sun_family = AF_UNIX;
  85. strcpy(s_un.sun_path, path);
  86. if (protocol == NULL)
  87. protocol = "tcp";
  88. /* map protocol name to protocol number */
  89. pe = getprotobyname(protocol);
  90. if (pe == NULL) {
  91. fprintf(stderr, "%s: Unknown protocol.n", protocol);
  92. return (-1);
  93. }
  94. /* Allocate a socket */
  95. s = socket(PF_UNIX, strcmp(protocol, "tcp") ? SOCK_DGRAM : SOCK_STREAM, 0);
  96. if (s < 0) {
  97. printf("protocol %dn", pe->p_proto);
  98. perror("socket");
  99. return -1;
  100. }
  101. /* standalonesetup(s); */
  102. signal(SIGHUP, SIG_IGN);
  103. signal(SIGUSR1, SIG_IGN);
  104. signal(SIGCHLD, reapchild);
  105. UNIX_SERVER_PATH = path;
  106. signal(SIGINT, doremove);
  107. signal(SIGTERM, doremove);
  109. chdir("/");
  110. if (bind(s, (struct sockaddr *) & s_un, sizeof(struct sockaddr_un)) < 0) {
  111. perror("bind");
  112. perror(path);
  113. return -1;
  114. }
  115. listen(s, 10);
  116. return s;
  117. }
  118. initinetserver(service, protocol)
  119. char   *service;
  120. char   *protocol;
  121. {
  122. struct servent *se; /* service information entry */
  123. struct hostent *he; /* host information entry */
  124. struct protoent *pe; /* protocol information entry */
  125. struct sockaddr_in sin; /* Internet endpoint address */
  126. int     port, s;
  127. int     randomport = 0;
  128. bzero((char *) &sin, sizeof(sin));
  129. sin.sin_family = AF_INET;
  130. if (!strcmp("0", service)) {
  131. randomport = 1;
  132. sin.sin_addr.s_addr = INADDR_ANY;
  133. }
  134. if (service == NULL)
  135. service = DEFAULTPORT;
  136. if (protocol == NULL)
  137. protocol = "tcp";
  138. /* map service name to port number */
  139. /* service ---> port */
  140. se = getservbyname(service, protocol);
  141. if (se == NULL) {
  142. port = htons((u_short) atoi(service));
  143. if (port == 0 && !randomport) {
  144. fprintf(stderr, "%s/%s: Unknown service.n", service, protocol);
  145. return (-1);
  146. }
  147. } else
  148. port = se->s_port;
  149. sin.sin_port = port;
  151. /* map protocol name to protocol number */
  152. pe = getprotobyname(protocol);
  153. if (pe == NULL) {
  154. fprintf(stderr, "%s: Unknown protocol.n", protocol);
  155. return (-1);
  156. }
  157. /* Allocate a socket */
  158. s = socket(PF_INET, strcmp(protocol, "tcp") ? SOCK_DGRAM : SOCK_STREAM, pe->p_proto);
  159. if (s < 0) {
  160. perror("socket");
  161. return -1;
  162. }
  163. standalonesetup(s);
  164. signal(SIGHUP, SIG_IGN);
  165. signal(SIGUSR1, SIG_IGN);
  166. signal(SIGCHLD, reapchild);
  167. signal(SIGINT, dokill);
  168. signal(SIGTERM, dokill);
  170. chdir("/");
  171. if (bind(s, (struct sockaddr *) & sin, sizeof(struct sockaddr_in)) < 0) {
  172. perror("bind");
  173. return -1;
  174. }
  175. listen(s, 10);
  176. #ifdef DEBUG
  177. {
  178. int     length = sizeof(sin);
  179. getsockname(s, &sin, &length);
  180. printf("portnum alocalted %dn", sin.sin_port);
  181. }
  182. #endif
  183. return s;
  184. }
  186. int 
  187. open_unix_listen(path, protocol, initfunc)
  188. char   *path;
  189. char   *protocol;
  190. int     (*initfunc) ARG((int));
  191. {
  192. int     s;
  193. s = initunixserver(path, protocol);
  194. if (s < 0) {
  195. return -1;
  196. }
  197. if (initfunc != NULL) {
  198. printf("in inetsingleserver before initfunc s %dn", s);
  199. if ((*initfunc) (s) < 0) {
  200. perror("initfunc error");
  201. return -1;
  202. }
  203. printf("end inetsingleserver before initfunc n");
  204. }
  205. return s;
  206. }
  208. int 
  209. open_listen(service, protocol, initfunc)
  210. char   *service;
  211. char   *protocol;
  212. int     (*initfunc) ARG((int));
  213. {
  214. int     s;
  215. if (!INETDstart)
  216. s = initinetserver(service, protocol);
  217. else
  218. s = 0;
  219. if (s < 0) {
  220. return -1;
  221. }
  222. if (initfunc != NULL) {
  223. printf("in inetsingleserver before initfunc s %dn", s);
  224. if ((*initfunc) (s) < 0) {
  225. perror("initfunc error");
  226. return -1;
  227. }
  228. printf("end inetsingleserver before initfunc n");
  229. }
  230. return s;
  231. }
  233. int 
  234. inetsingleserver(service, protocol, serverfunc, initfunc)
  235. char   *service;
  236. char   *protocol;
  237. int     (*initfunc) ARG((int));
  238. int     (*serverfunc) ARG((int));
  239. {
  240. int     s;
  241. if (!INETDstart)
  242. s = initinetserver(service, protocol);
  243. else
  244. s = 0;
  245. if (s < 0) {
  246. return -1;
  247. }
  248. if (initfunc != NULL) {
  249. printf("in inetsingleserver before initfunc s %dn", s);
  250. if ((*initfunc) (s) < 0) {
  251. perror("initfunc error");
  252. return -1;
  253. }
  254. printf("end inetsingleserver before initfunc n");
  255. } {
  256. int     ns = tryaccept(s);
  257. int     result = 0;
  258. if (ns < 0 && errno != EINTR) {
  259. #ifdef DEBUGSERVER
  260. perror("accept");
  261. #endif
  262. }
  263. close(s);
  264. if (serverfunc != NULL)
  265. result = (*serverfunc) (ns);
  266. close(ns);
  267. return (result);
  268. }
  269. }
  272. int 
  273. tryaccept(s)
  274. int     s;
  275. {
  276. int     ns, fromlen;
  277. struct sockaddr sockaddr; /* Internet endpoint address */
  278. fromlen = sizeof(struct sockaddr_in);
  280. #ifdef DEBUGSERVER
  281. fputs("Listening againn", stdout);
  282. #endif
  283. do {
  284. ns = accept(s, &sockaddr, &fromlen);
  285. errno = 0;
  286. } while (ns < 0 && errno == EINTR);
  287. return ns;
  288. }
  290. int 
  291. inetserver(service, protocol, serverfunc)
  292. char   *service;
  293. char   *protocol;
  294. int     (*serverfunc) ARG((int));
  295. {
  296. int     port, s;
  297. if (!INETDstart)
  298. s = initinetserver(service, protocol);
  299. else
  300. s = 0;
  301. if (s < 0) {
  302. return -1;
  303. }
  304. for (;;) {
  305. int     ns = tryaccept(s);
  306. int     result = 0;
  307. int     pid;
  308. if (ns < 0 && errno != EINTR) {
  309. #ifdef DEBUGSERVER
  310. perror("accept");
  311. #endif
  312. continue;
  313. }
  314. #ifdef DEBUGSERVER
  315. fputs("Accept OKn", stdout);
  316. #endif
  317. pid = fork();
  318. if (pid == 0) {
  319. close(s);
  320. if (serverfunc != NULL)
  321. result = (*serverfunc) (ns);
  322. close(ns);
  323. exit(result);
  324. } else if (pid < 0) {
  325. perror("fork");
  326. return -1;
  327. }
  328. close(ns);
  329. }
  330. return 0;
  331. }
  333. int 
  334. inetclient(server, service, protocol)
  335. char   *server;
  336. char   *protocol;
  337. char   *service;
  338. {
  339. struct servent *se; /* service information entry */
  340. struct hostent *he; /* host information entry */
  341. struct protoent *pe; /* protocol information entry */
  342. struct sockaddr_in sin; /* Internet endpoint address */
  343. int     port, s;
  344. bzero((char *) &sin, sizeof(sin));
  345. sin.sin_family = AF_INET;
  347. if (service == NULL)
  348. service = DEFAULTPORT;
  349. if (protocol == NULL)
  350. protocol = "tcp";
  351. if (server == NULL)
  352. server = DEFAULTSERVER;
  353. /* map service name to port number */
  354. /* service ---> port */
  355. se = getservbyname(service, protocol);
  356. if (se == NULL) {
  357. port = htons((u_short) atoi(service));
  358. if (port == 0) {
  359. fprintf(stderr, "%s/%s: Unknown service.n", service, protocol);
  360. return (-1);
  361. }
  362. } else
  363. port = se->s_port;
  364. sin.sin_port = port;
  366. /* map server hostname to IP address, allowing for dotted decimal */
  367. he = gethostbyname(server);
  368. if (he == NULL) {
  369. sin.sin_addr.s_addr = inet_addr(server);
  370. if (sin.sin_addr.s_addr == INADDR_NONE) {
  371. fprintf(stderr, "%s: Unknown host.n", server);
  372. return (-1);
  373. }
  374. } else
  375. bcopy(he->h_addr, (char *) &sin.sin_addr, he->h_length);
  377. /* map protocol name to protocol number */
  378. pe = getprotobyname(protocol);
  379. if (pe == NULL) {
  380. fprintf(stderr, "%s: Unknown protocol.n", protocol);
  381. return (-1);
  382. }
  383. /* Allocate a socket */
  384. s = socket(PF_INET, strcmp(protocol, "tcp") ? SOCK_DGRAM : SOCK_STREAM, pe->p_proto);
  385. if (s < 0) {
  386. perror("socket");
  387. return -1;
  388. }
  389. /* Connect the socket to the server */
  390. if (connect(s, (struct sockaddr *) & sin, sizeof(sin)) < 0) {
  391. /* perror("connect"); */
  392. return -1;
  393. }
  394. return s;
  395. }
  397. int 
  398. unixclient(path, protocol)
  399. char   *path;
  400. char   *protocol;
  401. {
  402. struct protoent *pe; /* protocol information entry */
  403. struct sockaddr_un s_un;/* unix endpoint address */
  404. int     s;
  405. bzero((char *) &s_un, sizeof(s_un));
  406. s_un.sun_family = AF_UNIX;
  408. if (path == NULL)
  409. path = DEFAULTPATH;
  410. if (protocol == NULL)
  411. protocol = "tcp";
  412. strcpy(s_un.sun_path, path);
  414. /* map protocol name to protocol number */
  415. pe = getprotobyname(protocol);
  416. if (pe == NULL) {
  417. fprintf(stderr, "%s: Unknown protocol.n", protocol);
  418. return (-1);
  419. }
  420. /* Allocate a socket */
  421. s = socket(PF_UNIX, strcmp(protocol, "tcp") ? SOCK_DGRAM : SOCK_STREAM, 0);
  422. if (s < 0) {
  423. perror("socket");
  424. return -1;
  425. }
  426. /* Connect the socket to the server */
  427. if (connect(s, (struct sockaddr *) & s_un, sizeof(s_un)) < 0) {
  428. /* perror("connect"); */
  429. return -1;
  430. }
  431. return s;
  432. }