sys/netinet/libalias/alias_skinny.c

   1 /*-
   2  * alias_skinny.c
   3  *
   4  * Copyright (c) 2002, 2003 MarcusCom, Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * Author: Joe Marcus Clarke <marcus@FreeBSD.org>
  29  *
  30  * $FreeBSD$
  31  */
  32
  33 #ifdef _KERNEL
  34 #include <sys/param.h>
  35 #else
  36 #include <sys/types.h>
  37 #include <sys/socket.h>
  38 #include <stdio.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #include <arpa/inet.h>
  42 #endif
  43
  44 #include <netinet/in_systm.h>
  45 #include <netinet/in.h>
  46 #include <netinet/ip.h>
  47 #include <netinet/tcp.h>
  48 #include <netinet/udp.h>
  49
  50 #ifdef _KERNEL
  51 #include <netinet/libalias/alias.h>
  52 #include <netinet/libalias/alias_local.h>
  53 #else
  54 #include "alias_local.h"
  55 #endif
  56
  57 /*
  58  * alias_skinny.c handles the translation for the Cisco Skinny Station
  59  * protocol.  Skinny typically uses TCP port 2000 to set up calls between
  60  * a Cisco Call Manager and a Cisco IP phone.  When a phone comes on line,
  61  * it first needs to register with the Call Manager.  To do this it sends
  62  * a registration message.  This message contains the IP address of the
  63  * IP phone.  This message must then be translated to reflect our global
  64  * IP address.  Along with the registration message (and usually in the
  65  * same packet), the phone sends an IP port message.  This message indicates
  66  * the TCP port over which it will communicate.
  67  *
  68  * When a call is placed from the phone, the Call Manager will send an
  69  * Open Receive Channel message to the phone to let the caller know someone
  70  * has answered.  The phone then sends back an Open Receive Channel
  71  * Acknowledgement.  In this packet, the phone sends its IP address again,
  72  * and the UDP port over which the voice traffic should flow.  These values
  73  * need translation.  Right after the Open Receive Channel Acknowledgement,
  74  * the Call Manager sends a Start Media Transmission message indicating the
  75  * call is connected.  This message contains the IP address and UDP port
  76  * number of the remote (called) party.  Once this message is translated, the
  77  * call can commence.  The called part sends the first UDP packet to the
  78  * calling phone at the pre-arranged UDP port in the Open Receive Channel
  79  * Acknowledgement.
  80  *
  81  * Skinny is a Cisco-proprietary protocol and is a trademark of Cisco Systems,
  82  * Inc.  All rights reserved.
  83 */
  84
  85 /* #define LIBALIAS_DEBUG 1 */
  86
  87 /* Message types that need translating */
  88 #define REG_MSG         0x00000001
  89 #define IP_PORT_MSG     0x00000002
  90 #define OPNRCVCH_ACK    0x00000022
  91 #define START_MEDIATX   0x0000008a
  92
  93 struct skinny_header {
  94         u_int32_t       len;
  95         u_int32_t       reserved;
  96         u_int32_t       msgId;
  97 };
  98
  99 struct RegisterMessage {
 100         u_int32_t       msgId;
 101         char            devName   [16];
 102         u_int32_t       uid;
 103         u_int32_t       instance;
 104         u_int32_t       ipAddr;
 105         u_char          devType;
 106         u_int32_t       maxStreams;
 107 };
 108
 109 struct IpPortMessage {
 110         u_int32_t       msgId;
 111         u_int32_t       stationIpPort;  /* Note: Skinny uses 32-bit port
 112                                          * numbers */
 113 };
 114
 115 struct OpenReceiveChannelAck {
 116         u_int32_t       msgId;
 117         u_int32_t       status;
 118         u_int32_t       ipAddr;
 119         u_int32_t       port;
 120         u_int32_t       passThruPartyID;
 121 };
 122
 123 struct StartMediaTransmission {
 124         u_int32_t       msgId;
 125         u_int32_t       conferenceID;
 126         u_int32_t       passThruPartyID;
 127         u_int32_t       remoteIpAddr;
 128         u_int32_t       remotePort;
 129         u_int32_t       MSPacket;
 130         u_int32_t       payloadCap;
 131         u_int32_t       precedence;
 132         u_int32_t       silenceSuppression;
 133         u_short         maxFramesPerPacket;
 134         u_int32_t       G723BitRate;
 135 };
 136
 137 typedef enum {
 138         ClientToServer = 0,
 139         ServerToClient = 1
 140 } ConvDirection;
 141
 142
 143 static int
 144 alias_skinny_reg_msg(struct RegisterMessage *reg_msg, struct ip *pip,
 145     struct tcphdr *tc, struct alias_link *lnk,
 146     ConvDirection direction)
 147 {
 148         (void)direction;
 149
 150         reg_msg->ipAddr = (u_int32_t) GetAliasAddress(lnk).s_addr;
 151
 152         tc->th_sum = 0;
 153         tc->th_sum = TcpChecksum(pip);
 154
 155         return (0);
 156 }
 157
 158 static int
 159 alias_skinny_startmedia(struct StartMediaTransmission *start_media,
 160     struct ip *pip, struct tcphdr *tc,
 161     struct alias_link *lnk, u_int32_t localIpAddr,
 162     ConvDirection direction)
 163 {
 164         struct in_addr dst, src;
 165
 166         (void)pip;
 167         (void)tc;
 168         (void)lnk;
 169         (void)direction;
 170
 171         dst.s_addr = start_media->remoteIpAddr;
 172         src.s_addr = localIpAddr;
 173
 174         /*
 175          * XXX I should probably handle in bound global translations as
 176          * well.
 177          */
 178
 179         return (0);
 180 }
 181
 182 static int
 183 alias_skinny_port_msg(struct IpPortMessage *port_msg, struct ip *pip,
 184     struct tcphdr *tc, struct alias_link *lnk,
 185     ConvDirection direction)
 186 {
 187         (void)direction;
 188
 189         port_msg->stationIpPort = (u_int32_t) ntohs(GetAliasPort(lnk));
 190
 191         tc->th_sum = 0;
 192         tc->th_sum = TcpChecksum(pip);
 193
 194         return (0);
 195 }
 196
 197 static int
 198 alias_skinny_opnrcvch_ack(struct libalias *la, struct OpenReceiveChannelAck *opnrcvch_ack,
 199     struct ip *pip, struct tcphdr *tc,
 200     struct alias_link *lnk, u_int32_t * localIpAddr,
 201     ConvDirection direction)
 202 {
 203         struct in_addr null_addr;
 204         struct alias_link *opnrcv_lnk;
 205         u_int32_t localPort;
 206
 207         (void)lnk;
 208         (void)direction;
 209
 210         *localIpAddr = (u_int32_t) opnrcvch_ack->ipAddr;
 211         localPort = opnrcvch_ack->port;
 212
 213         null_addr.s_addr = INADDR_ANY;
 214         opnrcv_lnk = FindUdpTcpOut(la, pip->ip_src, null_addr,
 215             htons((u_short) opnrcvch_ack->port), 0,
 216             IPPROTO_UDP, 1);
 217         opnrcvch_ack->ipAddr = (u_int32_t) GetAliasAddress(opnrcv_lnk).s_addr;
 218         opnrcvch_ack->port = (u_int32_t) ntohs(GetAliasPort(opnrcv_lnk));
 219
 220         tc->th_sum = 0;
 221         tc->th_sum = TcpChecksum(pip);
 222
 223         return (0);
 224 }
 225
 226 void
 227 AliasHandleSkinny(struct libalias *la, struct ip *pip, struct alias_link *lnk)
 228 {
 229         size_t hlen, tlen, dlen;
 230         struct tcphdr *tc;
 231         u_int32_t msgId, t, len, lip;
 232         struct skinny_header *sd;
 233         size_t orig_len, skinny_hdr_len = sizeof(struct skinny_header);
 234         ConvDirection direction;
 235
 236         tc = (struct tcphdr *)ip_next(pip);
 237         hlen = (pip->ip_hl + tc->th_off) << 2;
 238         tlen = ntohs(pip->ip_len);
 239         dlen = tlen - hlen;
 240
 241         sd = (struct skinny_header *)tcp_next(tc);
 242
 243         /*
 244          * XXX This direction is reserved for future use.  I still need to
 245          * handle the scenario where the call manager is on the inside, and
 246          * the calling phone is on the global outside.
 247          */
 248         if (ntohs(tc->th_dport) == la->skinnyPort) {
 249                 direction = ClientToServer;
 250         } else if (ntohs(tc->th_sport) == la->skinnyPort) {
 251                 direction = ServerToClient;
 252         } else {
 253 #ifdef LIBALIAS_DEBUG
 254                 fprintf(stderr,
 255                     "PacketAlias/Skinny: Invalid port number, not a Skinny packet\n");
 256 #endif
 257                 return;
 258         }
 259
 260         orig_len = dlen;
 261         /*
 262          * Skinny packets can contain many messages.  We need to loop
 263          * through the packet using len to determine message boundaries.
 264          * This comes into play big time with port messages being in the
 265          * same packet as register messages.  Also, open receive channel
 266          * acks are usually buried in a pakcet some 400 bytes long.
 267          */
 268         while (dlen >= skinny_hdr_len) {
 269                 len = (sd->len);
 270                 msgId = (sd->msgId);
 271                 t = len;
 272
 273                 if (t > orig_len || t > dlen) {
 274 #ifdef LIBALIAS_DEBUG
 275                         fprintf(stderr,
 276                             "PacketAlias/Skinny: Not a skinny packet, invalid length \n");
 277 #endif
 278                         return;
 279                 }
 280                 switch (msgId) {
 281                 case REG_MSG: {
 282                         struct RegisterMessage *reg_mesg;
 283
 284                         if (len < (int)sizeof(struct RegisterMessage)) {
 285 #ifdef LIBALIAS_DEBUG
 286                                 fprintf(stderr,
 287                                     "PacketAlias/Skinny: Not a skinny packet, bad registration message\n");
 288 #endif
 289                                 return;
 290                         }
 291                         reg_mesg = (struct RegisterMessage *)&sd->msgId;
 292 #ifdef LIBALIAS_DEBUG
 293                         fprintf(stderr,
 294                             "PacketAlias/Skinny: Received a register message");
 295 #endif
 296                         alias_skinny_reg_msg(reg_mesg, pip, tc, lnk, direction);
 297                         break;
 298                 }
 299                 case IP_PORT_MSG: {
 300                         struct IpPortMessage *port_mesg;
 301
 302                         if (len < (int)sizeof(struct IpPortMessage)) {
 303 #ifdef LIBALIAS_DEBUG
 304                                 fprintf(stderr,
 305                                     "PacketAlias/Skinny: Not a skinny packet, port message\n");
 306 #endif
 307                                 return;
 308                         }
 309 #ifdef LIBALIAS_DEBUG
 310                         fprintf(stderr,
 311                             "PacketAlias/Skinny: Received ipport message\n");
 312 #endif
 313                         port_mesg = (struct IpPortMessage *)&sd->msgId;
 314                         alias_skinny_port_msg(port_mesg, pip, tc, lnk, direction);
 315                         break;
 316                 }
 317                 case OPNRCVCH_ACK: {
 318                         struct OpenReceiveChannelAck *opnrcvchn_ack;
 319
 320                         if (len < (int)sizeof(struct OpenReceiveChannelAck)) {
 321 #ifdef LIBALIAS_DEBUG
 322                                 fprintf(stderr,
 323                                     "PacketAlias/Skinny: Not a skinny packet, packet,OpnRcvChnAckMsg\n");
 324 #endif
 325                                 return;
 326                         }
 327 #ifdef LIBALIAS_DEBUG
 328                         fprintf(stderr,
 329                             "PacketAlias/Skinny: Received open rcv channel msg\n");
 330 #endif
 331                         opnrcvchn_ack = (struct OpenReceiveChannelAck *)&sd->msgId;
 332                         alias_skinny_opnrcvch_ack(la, opnrcvchn_ack, pip, tc, lnk, &lip, direction);
 333                         break;
 334                 }
 335                 case START_MEDIATX: {
 336                         struct StartMediaTransmission *startmedia_tx;
 337
 338                         if (len < (int)sizeof(struct StartMediaTransmission)) {
 339 #ifdef LIBALIAS_DEBUG
 340                                 fprintf(stderr,
 341                                     "PacketAlias/Skinny: Not a skinny packet,StartMediaTx Message\n");
 342 #endif
 343                                 return;
 344                         }
 345 #ifdef LIBALIAS_DEBUG
 346                         fprintf(stderr,
 347                             "PacketAlias/Skinny: Received start media trans msg\n");
 348 #endif
 349                         startmedia_tx = (struct StartMediaTransmission *)&sd->msgId;
 350                         alias_skinny_startmedia(startmedia_tx, pip, tc, lnk, lip, direction);
 351                         break;
 352                 }
 353                 default:
 354                         break;
 355                 }
 356                 /* Place the pointer at the next message in the packet. */
 357                 dlen -= len + (skinny_hdr_len - sizeof(msgId));
 358                 sd = (struct skinny_header *)(((char *)&sd->msgId) + len);
 359         }
 360 }