1 /* 2 * Copyright (c) 2011-2014 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@dragonflybsd.org> 6 * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org> 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * 3. Neither the name of The DragonFly Project nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific, prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 25 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 26 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 27 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 28 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 30 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 31 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 32 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #include "dmsg_local.h" 37 38 static void master_auth_signal(dmsg_iocom_t *iocom); 39 static void master_auth_rxmsg(dmsg_msg_t *msg); 40 static void master_link_signal(dmsg_iocom_t *iocom); 41 static void master_link_rxmsg(dmsg_msg_t *msg); 42 43 /* 44 * Service an accepted connection (runs as a pthread) 45 * 46 * (also called from a couple of other places) 47 */ 48 void * 49 dmsg_master_service(void *data) 50 { 51 dmsg_master_service_info_t *info = data; 52 dmsg_iocom_t iocom; 53 54 if (info->detachme) 55 pthread_detach(pthread_self()); 56 57 dmsg_iocom_init(&iocom, 58 info->fd, 59 (info->altmsg_callback ? info->altfd : -1), 60 master_auth_signal, 61 master_auth_rxmsg, 62 info->usrmsg_callback, 63 info->altmsg_callback); 64 if (info->noclosealt) 65 iocom.flags &= ~DMSG_IOCOMF_CLOSEALT; 66 if (info->label) { 67 dmsg_iocom_label(&iocom, "%s", info->label); 68 free(info->label); 69 info->label = NULL; 70 } 71 dmsg_iocom_core(&iocom); 72 dmsg_iocom_done(&iocom); 73 74 dmio_printf(iocom, 1, 75 "iocom on fd %d terminated error rx=%d, tx=%d\n", 76 info->fd, iocom.ioq_rx.error, iocom.ioq_tx.error); 77 close(info->fd); 78 info->fd = -1; /* safety */ 79 if (info->exit_callback) 80 info->exit_callback(info->handle); 81 free(info); 82 83 return (NULL); 84 } 85 86 /************************************************************************ 87 * AUTHENTICATION * 88 ************************************************************************ 89 * 90 * Callback via dmsg_iocom_core(). 91 * 92 * Additional messaging-based authentication must occur before normal 93 * message operation. The connection has already been encrypted at 94 * this point. 95 */ 96 static void master_auth_conn_rx(dmsg_msg_t *msg); 97 98 static 99 void 100 master_auth_signal(dmsg_iocom_t *iocom) 101 { 102 dmsg_msg_t *msg; 103 104 /* 105 * Transmit LNK_CONN, enabling the SPAN protocol if both sides 106 * agree. 107 * 108 * XXX put additional authentication states here? 109 */ 110 msg = dmsg_msg_alloc(&iocom->state0, 0, 111 DMSG_LNK_CONN | DMSGF_CREATE, 112 master_auth_conn_rx, NULL); 113 msg->any.lnk_conn.peer_mask = (uint64_t)-1; 114 msg->any.lnk_conn.peer_type = DMSG_PEER_ROUTER; 115 msg->any.lnk_conn.peer_mask = (uint64_t)-1; 116 117 dmsg_msg_write(msg); 118 119 dmsg_iocom_restate(iocom, master_link_signal, master_link_rxmsg); 120 } 121 122 static 123 void 124 master_auth_conn_rx(dmsg_msg_t *msg) 125 { 126 if (msg->any.head.cmd & DMSGF_DELETE) 127 dmsg_msg_reply(msg, 0); 128 } 129 130 static 131 void 132 master_auth_rxmsg(dmsg_msg_t *msg __unused) 133 { 134 } 135 136 /************************************************************************ 137 * POST-AUTHENTICATION SERVICE MSGS * 138 ************************************************************************ 139 * 140 * Callback via dmsg_iocom_core(). 141 */ 142 static 143 void 144 master_link_signal(dmsg_iocom_t *iocom) 145 { 146 dmsg_msg_lnk_signal(iocom); 147 } 148 149 static 150 void 151 master_link_rxmsg(dmsg_msg_t *msg) 152 { 153 dmsg_state_t *state; 154 dmsg_iocom_t *iocom; 155 uint32_t cmd; 156 157 /* 158 * If the message state has a function established we just 159 * call the function, otherwise we call the appropriate 160 * link-level protocol related to the original command and 161 * let it sort it out. 162 * 163 * Non-transactional one-off messages, on the otherhand, 164 * might have REPLY set. 165 */ 166 state = msg->state; 167 iocom = state->iocom; 168 cmd = (state != &iocom->state0) ? state->icmd : msg->any.head.cmd; 169 170 if (state->func) { 171 /* 172 * Call function or router 173 */ 174 assert(state != &iocom->state0); 175 state->func(msg); 176 } else { 177 /* 178 * Top-level message 179 */ 180 switch(cmd & DMSGF_PROTOS) { 181 case DMSG_PROTO_LNK: 182 dmsg_msg_lnk(msg); 183 break; 184 case DMSG_PROTO_DBG: 185 dmsg_msg_dbg(msg); 186 break; 187 default: 188 iocom->usrmsg_callback(msg, 1); 189 break; 190 } 191 } 192 } 193 194 /* 195 * This is called from the master node to process a received debug 196 * shell command. We process the command, outputting the results, 197 * then finish up by outputting another prompt. 198 */ 199 void 200 dmsg_msg_dbg(dmsg_msg_t *msg) 201 { 202 dmsg_iocom_t *iocom = msg->state->iocom; 203 204 switch(msg->tcmd & DMSGF_CMDSWMASK) { 205 case DMSG_DBG_SHELL: 206 /* 207 * This is a command which we must process. 208 * When we are finished we generate a final reply. 209 */ 210 if (msg->aux_data) 211 msg->aux_data[msg->aux_size - 1] = 0; 212 iocom->usrmsg_callback(msg, 0); 213 break; 214 case DMSG_DBG_SHELL | DMSGF_REPLY: 215 /* 216 * A reply just prints out the string. No newline is added 217 * (it is expected to be embedded if desired). 218 */ 219 if (msg->aux_data) 220 msg->aux_data[msg->aux_size - 1] = 0; 221 if (msg->aux_data) 222 write(2, msg->aux_data, strlen(msg->aux_data)); 223 break; 224 default: 225 iocom->usrmsg_callback(msg, 1); 226 break; 227 } 228 } 229 230 /* 231 * Returns text debug output to the original defined by (msg). (msg) is 232 * not modified and stays intact. We use a one-way message with REPLY set 233 * to distinguish between a debug command and debug terminal output. 234 * 235 * To prevent loops dmsg_printf() can filter the message (cmd) related 236 * to the dmsg_printf(). We filter out DBG messages. 237 */ 238 void 239 dmsg_printf(dmsg_iocom_t *iocom, const char *ctl, ...) 240 { 241 dmsg_msg_t *rmsg; 242 va_list va; 243 char buf[1024]; 244 size_t len; 245 246 va_start(va, ctl); 247 vsnprintf(buf, sizeof(buf), ctl, va); 248 va_end(va); 249 len = strlen(buf) + 1; 250 251 rmsg = dmsg_msg_alloc(&iocom->state0, len, 252 DMSG_DBG_SHELL | DMSGF_REPLY, 253 NULL, NULL); 254 bcopy(buf, rmsg->aux_data, len); 255 256 dmsg_msg_write(rmsg); 257 } 258