1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * Copyright (c) 2018, Joyent, Inc. 28 */ 29 30 #include <stdio.h> 31 #include <stdlib.h> 32 #include <string.h> 33 #include <strings.h> 34 #include <sys/types.h> 35 #include <errno.h> 36 #include <syslog.h> 37 #include <unistd.h> 38 #include <sys/types.h> 39 #include <sys/socket.h> 40 #include <sys/time.h> 41 #include <netinet/in.h> 42 #include <arpa/inet.h> 43 #include <netdb.h> 44 #include <sys/stat.h> 45 #include <sys/sdt.h> 46 #include <signal.h> 47 #include <fcntl.h> 48 #include <libstmfproxy.h> 49 50 /* 51 * NOTE: 52 * This is demo code to be used with the existing demo proxy daemon 53 * svc-stmfproxy in /usr/demo/comstar. 54 */ 55 56 struct _s_handle { 57 int sockfd; 58 }; 59 60 typedef struct _s_handle s_handle_t; 61 62 static ssize_t 63 pt_socket_recv(void *handle, void *buf, size_t len) 64 { 65 s_handle_t *sh = handle; 66 67 return (recv(sh->sockfd, buf, len, MSG_WAITALL)); 68 } 69 70 static ssize_t 71 pt_socket_send(void *handle, void *buf, size_t len) 72 { 73 s_handle_t *sh = handle; 74 75 return (send(sh->sockfd, buf, len, 0)); 76 } 77 78 static void * 79 pt_socket_connect(int server_node, char *server) 80 { 81 int sfd, new_sfd; 82 s_handle_t *sh = NULL; 83 int on = 1; 84 struct sockaddr_in cli_addr, serv_addr; 85 struct sockaddr_in sin; 86 int cliLen = sizeof (cli_addr); 87 88 if ((sfd = socket(AF_INET, SOCK_STREAM, 0)) <= 0) { 89 syslog(LOG_DAEMON|LOG_WARNING, 90 "socket() call failed: %d", errno); 91 return (NULL); 92 } 93 94 if (server_node) { 95 96 if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &on, 97 sizeof (on)) < 0) { 98 syslog(LOG_DAEMON|LOG_WARNING, 99 "setsockopt() failed: %d", errno); 100 goto serv_out; 101 } 102 103 bzero(&serv_addr, sizeof (serv_addr)); 104 serv_addr.sin_family = AF_INET; 105 serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); 106 /* XXX get from smf? */ 107 serv_addr.sin_port = htons(6543); 108 109 if (bind(sfd, (struct sockaddr *)&serv_addr, 110 sizeof (serv_addr)) < 0) { 111 syslog(LOG_DAEMON|LOG_WARNING, "bind() call failed: %d", 112 errno); 113 goto serv_out; 114 } 115 116 (void) listen(sfd, 5); 117 118 new_sfd = accept(sfd, (struct sockaddr *)&cli_addr, &cliLen); 119 120 if (new_sfd < 0) { 121 syslog(LOG_DAEMON|LOG_WARNING, "accept failed: %d", 122 errno); 123 goto serv_out; 124 } 125 sh = malloc(sizeof (*sh)); 126 sh->sockfd = new_sfd; 127 serv_out: 128 (void) close(sfd); 129 } else { 130 struct hostent *hp; 131 132 /* 133 * Assume IP dot notation or if that fails, gethostbyname() 134 * If that fails, return 135 */ 136 if ((inet_aton(server, &sin.sin_addr)) == 0) { 137 if ((hp = gethostbyname(server)) != NULL) { 138 memcpy(&sin.sin_addr.s_addr, hp->h_addr, 139 hp->h_length); 140 } else { 141 syslog(LOG_DAEMON|LOG_CRIT, 142 "Cannot get IP address for %s", server); 143 (void) close(sfd); 144 return (NULL); 145 } 146 } else { 147 fprintf(stderr, 148 "Sorry, cannot use ip address format\n"); 149 (void) close(sfd); 150 return (NULL); 151 } 152 sin.sin_family = AF_INET; 153 /* XXX pass in from smf */ 154 sin.sin_port = htons(6543); 155 156 while (connect(sfd, (struct sockaddr *)&sin, 157 sizeof (sin)) < 0) { 158 (void) close(sfd); 159 if (errno == ECONNREFUSED) { 160 /* get a fresh socket and retry */ 161 sfd = socket(AF_INET, SOCK_STREAM, 0); 162 if (sfd < 0) { 163 syslog(LOG_DAEMON|LOG_WARNING, 164 "socket() call failed: %d", errno); 165 return (NULL); 166 } 167 (void) sleep(2); 168 } else { 169 syslog(LOG_DAEMON|LOG_CRIT, 170 "Cannot connect %s - %d", server, errno); 171 return (NULL); 172 } 173 } 174 sh = malloc(sizeof (*sh)); 175 sh->sockfd = sfd; 176 } 177 return (sh); 178 } 179 180 pt_ops_t pt_socket_ops = { 181 pt_socket_connect, 182 pt_socket_send, 183 pt_socket_recv 184 }; 185 186 int 187 stmf_proxy_transport_init(char *transport, pt_ops_t **pt_ops) 188 { 189 if (strcmp(transport, "sockets") == 0) { 190 *pt_ops = &pt_socket_ops; 191 return (0); 192 } else { 193 return (-1); 194 } 195 } 196