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 #ifdef _KERNEL
 154         tc->th_x2 = 1;
 155 #else
 156         tc->th_sum = TcpChecksum(pip);
 157 #endif
 158
 159         return (0);
 160 }
 161
 162 static int
 163 alias_skinny_startmedia(struct StartMediaTransmission *start_media,
 164     struct ip *pip, struct tcphdr *tc,
 165     struct alias_link *lnk, u_int32_t localIpAddr,
 166     ConvDirection direction)
 167 {
 168         struct in_addr dst, src;
 169
 170         (void)pip;
 171         (void)tc;
 172         (void)lnk;
 173         (void)direction;
 174
 175         dst.s_addr = start_media->remoteIpAddr;
 176         src.s_addr = localIpAddr;
 177
 178         /*
 179          * XXX I should probably handle in bound global translations as
 180          * well.
 181          */
 182
 183         return (0);
 184 }
 185
 186 static int
 187 alias_skinny_port_msg(struct IpPortMessage *port_msg, struct ip *pip,
 188     struct tcphdr *tc, struct alias_link *lnk,
 189     ConvDirection direction)
 190 {
 191         (void)direction;
 192
 193         port_msg->stationIpPort = (u_int32_t) ntohs(GetAliasPort(lnk));
 194
 195         tc->th_sum = 0;
 196 #ifdef _KERNEL
 197         tc->th_x2 = 1;
 198 #else
 199         tc->th_sum = TcpChecksum(pip);
 200 #endif
 201         return (0);
 202 }
 203
 204 static int
 205 alias_skinny_opnrcvch_ack(struct libalias *la, struct OpenReceiveChannelAck *opnrcvch_ack,
 206     struct ip *pip, struct tcphdr *tc,
 207     struct alias_link *lnk, u_int32_t * localIpAddr,
 208     ConvDirection direction)
 209 {
 210         struct in_addr null_addr;
 211         struct alias_link *opnrcv_lnk;
 212         u_int32_t localPort;
 213
 214         (void)lnk;
 215         (void)direction;
 216
 217         *localIpAddr = (u_int32_t) opnrcvch_ack->ipAddr;
 218         localPort = opnrcvch_ack->port;
 219
 220         null_addr.s_addr = INADDR_ANY;
 221         opnrcv_lnk = FindUdpTcpOut(la, pip->ip_src, null_addr,
 222             htons((u_short) opnrcvch_ack->port), 0,
 223             IPPROTO_UDP, 1);
 224         opnrcvch_ack->ipAddr = (u_int32_t) GetAliasAddress(opnrcv_lnk).s_addr;
 225         opnrcvch_ack->port = (u_int32_t) ntohs(GetAliasPort(opnrcv_lnk));
 226
 227         tc->th_sum = 0;
 228 #ifdef _KERNEL
 229         tc->th_x2 = 1;
 230 #else
 231         tc->th_sum = TcpChecksum(pip);
 232 #endif
 233         return (0);
 234 }
 235
 236 void
 237 AliasHandleSkinny(struct libalias *la, struct ip *pip, struct alias_link *lnk)
 238 {
 239         size_t hlen, tlen, dlen;
 240         struct tcphdr *tc;
 241         u_int32_t msgId, t, len, lip;
 242         struct skinny_header *sd;
 243         size_t orig_len, skinny_hdr_len = sizeof(struct skinny_header);
 244         ConvDirection direction;
 245
 246         tc = (struct tcphdr *)ip_next(pip);
 247         hlen = (pip->ip_hl + tc->th_off) << 2;
 248         tlen = ntohs(pip->ip_len);
 249         dlen = tlen - hlen;
 250
 251         sd = (struct skinny_header *)tcp_next(tc);
 252
 253         /*
 254          * XXX This direction is reserved for future use.  I still need to
 255          * handle the scenario where the call manager is on the inside, and
 256          * the calling phone is on the global outside.
 257          */
 258         if (ntohs(tc->th_dport) == la->skinnyPort) {
 259                 direction = ClientToServer;
 260         } else if (ntohs(tc->th_sport) == la->skinnyPort) {
 261                 direction = ServerToClient;
 262         } else {
 263 #ifdef LIBALIAS_DEBUG
 264                 fprintf(stderr,
 265                     "PacketAlias/Skinny: Invalid port number, not a Skinny packet\n");
 266 #endif
 267                 return;
 268         }
 269
 270         orig_len = dlen;
 271         /*
 272          * Skinny packets can contain many messages.  We need to loop
 273          * through the packet using len to determine message boundaries.
 274          * This comes into play big time with port messages being in the
 275          * same packet as register messages.  Also, open receive channel
 276          * acks are usually buried in a pakcet some 400 bytes long.
 277          */
 278         while (dlen >= skinny_hdr_len) {
 279                 len = (sd->len);
 280                 msgId = (sd->msgId);
 281                 t = len;
 282
 283                 if (t > orig_len || t > dlen) {
 284 #ifdef LIBALIAS_DEBUG
 285                         fprintf(stderr,
 286                             "PacketAlias/Skinny: Not a skinny packet, invalid length \n");
 287 #endif
 288                         return;
 289                 }
 290                 switch (msgId) {
 291                 case REG_MSG: {
 292                         struct RegisterMessage *reg_mesg;
 293
 294                         if (len < (int)sizeof(struct RegisterMessage)) {
 295 #ifdef LIBALIAS_DEBUG
 296                                 fprintf(stderr,
 297                                     "PacketAlias/Skinny: Not a skinny packet, bad registration message\n");
 298 #endif
 299                                 return;
 300                         }
 301                         reg_mesg = (struct RegisterMessage *)&sd->msgId;
 302 #ifdef LIBALIAS_DEBUG
 303                         fprintf(stderr,
 304                             "PacketAlias/Skinny: Received a register message");
 305 #endif
 306                         alias_skinny_reg_msg(reg_mesg, pip, tc, lnk, direction);
 307                         break;
 308                 }
 309                 case IP_PORT_MSG: {
 310                         struct IpPortMessage *port_mesg;
 311
 312                         if (len < (int)sizeof(struct IpPortMessage)) {
 313 #ifdef LIBALIAS_DEBUG
 314                                 fprintf(stderr,
 315                                     "PacketAlias/Skinny: Not a skinny packet, port message\n");
 316 #endif
 317                                 return;
 318                         }
 319 #ifdef LIBALIAS_DEBUG
 320                         fprintf(stderr,
 321                             "PacketAlias/Skinny: Received ipport message\n");
 322 #endif
 323                         port_mesg = (struct IpPortMessage *)&sd->msgId;
 324                         alias_skinny_port_msg(port_mesg, pip, tc, lnk, direction);
 325                         break;
 326                 }
 327                 case OPNRCVCH_ACK: {
 328                         struct OpenReceiveChannelAck *opnrcvchn_ack;
 329
 330                         if (len < (int)sizeof(struct OpenReceiveChannelAck)) {
 331 #ifdef LIBALIAS_DEBUG
 332                                 fprintf(stderr,
 333                                     "PacketAlias/Skinny: Not a skinny packet, packet,OpnRcvChnAckMsg\n");
 334 #endif
 335                                 return;
 336                         }
 337 #ifdef LIBALIAS_DEBUG
 338                         fprintf(stderr,
 339                             "PacketAlias/Skinny: Received open rcv channel msg\n");
 340 #endif
 341                         opnrcvchn_ack = (struct OpenReceiveChannelAck *)&sd->msgId;
 342                         alias_skinny_opnrcvch_ack(la, opnrcvchn_ack, pip, tc, lnk, &lip, direction);
 343                         break;
 344                 }
 345                 case START_MEDIATX: {
 346                         struct StartMediaTransmission *startmedia_tx;
 347
 348                         if (len < (int)sizeof(struct StartMediaTransmission)) {
 349 #ifdef LIBALIAS_DEBUG
 350                                 fprintf(stderr,
 351                                     "PacketAlias/Skinny: Not a skinny packet,StartMediaTx Message\n");
 352 #endif
 353                                 return;
 354                         }
 355 #ifdef LIBALIAS_DEBUG
 356                         fprintf(stderr,
 357                             "PacketAlias/Skinny: Received start media trans msg\n");
 358 #endif
 359                         startmedia_tx = (struct StartMediaTransmission *)&sd->msgId;
 360                         alias_skinny_startmedia(startmedia_tx, pip, tc, lnk, lip, direction);
 361                         break;
 362                 }
 363                 default:
 364                         break;
 365                 }
 366                 /* Place the pointer at the next message in the packet. */
 367                 dlen -= len + (skinny_hdr_len - sizeof(msgId));
 368                 sd = (struct skinny_header *)(((char *)&sd->msgId) + len);
 369         }
 370 }