4 * Copyright (c) 2002, 2003 MarcusCom, Inc.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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
28 * Author: Joe Marcus Clarke <marcus@FreeBSD.org>
34 #include <sys/param.h>
36 #include <sys/types.h>
37 #include <sys/socket.h>
41 #include <arpa/inet.h>
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>
51 #include <netinet/libalias/alias.h>
52 #include <netinet/libalias/alias_local.h>
54 #include "alias_local.h"
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.
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
81 * Skinny is a Cisco-proprietary protocol and is a trademark of Cisco Systems,
82 * Inc. All rights reserved.
85 /* #define LIBALIAS_DEBUG 1 */
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
93 struct skinny_header {
99 struct RegisterMessage {
106 u_int32_t maxStreams;
109 struct IpPortMessage {
111 u_int32_t stationIpPort; /* Note: Skinny uses 32-bit port
115 struct OpenReceiveChannelAck {
120 u_int32_t passThruPartyID;
123 struct StartMediaTransmission {
125 u_int32_t conferenceID;
126 u_int32_t passThruPartyID;
127 u_int32_t remoteIpAddr;
128 u_int32_t remotePort;
130 u_int32_t payloadCap;
131 u_int32_t precedence;
132 u_int32_t silenceSuppression;
133 u_short maxFramesPerPacket;
134 u_int32_t G723BitRate;
144 alias_skinny_reg_msg(struct RegisterMessage *reg_msg, struct ip *pip,
145 struct tcphdr *tc, struct alias_link *lnk,
146 ConvDirection direction)
150 reg_msg->ipAddr = (u_int32_t) GetAliasAddress(lnk).s_addr;
156 tc->th_sum = TcpChecksum(pip);
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)
168 struct in_addr dst, src;
175 dst.s_addr = start_media->remoteIpAddr;
176 src.s_addr = localIpAddr;
179 * XXX I should probably handle in bound global translations as
187 alias_skinny_port_msg(struct IpPortMessage *port_msg, struct ip *pip,
188 struct tcphdr *tc, struct alias_link *lnk,
189 ConvDirection direction)
193 port_msg->stationIpPort = (u_int32_t) ntohs(GetAliasPort(lnk));
199 tc->th_sum = TcpChecksum(pip);
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)
210 struct in_addr null_addr;
211 struct alias_link *opnrcv_lnk;
217 *localIpAddr = (u_int32_t) opnrcvch_ack->ipAddr;
218 localPort = opnrcvch_ack->port;
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,
224 opnrcvch_ack->ipAddr = (u_int32_t) GetAliasAddress(opnrcv_lnk).s_addr;
225 opnrcvch_ack->port = (u_int32_t) ntohs(GetAliasPort(opnrcv_lnk));
231 tc->th_sum = TcpChecksum(pip);
237 AliasHandleSkinny(struct libalias *la, struct ip *pip, struct alias_link *lnk)
239 size_t hlen, tlen, dlen;
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;
246 tc = (struct tcphdr *)ip_next(pip);
247 hlen = (pip->ip_hl + tc->th_off) << 2;
248 tlen = ntohs(pip->ip_len);
251 sd = (struct skinny_header *)tcp_next(tc);
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.
258 if (ntohs(tc->th_dport) == la->skinnyPort) {
259 direction = ClientToServer;
260 } else if (ntohs(tc->th_sport) == la->skinnyPort) {
261 direction = ServerToClient;
263 #ifdef LIBALIAS_DEBUG
265 "PacketAlias/Skinny: Invalid port number, not a Skinny packet\n");
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.
278 while (dlen >= skinny_hdr_len) {
283 if (t > orig_len || t > dlen) {
284 #ifdef LIBALIAS_DEBUG
286 "PacketAlias/Skinny: Not a skinny packet, invalid length \n");
292 struct RegisterMessage *reg_mesg;
294 if (len < (int)sizeof(struct RegisterMessage)) {
295 #ifdef LIBALIAS_DEBUG
297 "PacketAlias/Skinny: Not a skinny packet, bad registration message\n");
301 reg_mesg = (struct RegisterMessage *)&sd->msgId;
302 #ifdef LIBALIAS_DEBUG
304 "PacketAlias/Skinny: Received a register message");
306 alias_skinny_reg_msg(reg_mesg, pip, tc, lnk, direction);
310 struct IpPortMessage *port_mesg;
312 if (len < (int)sizeof(struct IpPortMessage)) {
313 #ifdef LIBALIAS_DEBUG
315 "PacketAlias/Skinny: Not a skinny packet, port message\n");
319 #ifdef LIBALIAS_DEBUG
321 "PacketAlias/Skinny: Received ipport message\n");
323 port_mesg = (struct IpPortMessage *)&sd->msgId;
324 alias_skinny_port_msg(port_mesg, pip, tc, lnk, direction);
328 struct OpenReceiveChannelAck *opnrcvchn_ack;
330 if (len < (int)sizeof(struct OpenReceiveChannelAck)) {
331 #ifdef LIBALIAS_DEBUG
333 "PacketAlias/Skinny: Not a skinny packet, packet,OpnRcvChnAckMsg\n");
337 #ifdef LIBALIAS_DEBUG
339 "PacketAlias/Skinny: Received open rcv channel msg\n");
341 opnrcvchn_ack = (struct OpenReceiveChannelAck *)&sd->msgId;
342 alias_skinny_opnrcvch_ack(la, opnrcvchn_ack, pip, tc, lnk, &lip, direction);
345 case START_MEDIATX: {
346 struct StartMediaTransmission *startmedia_tx;
348 if (len < (int)sizeof(struct StartMediaTransmission)) {
349 #ifdef LIBALIAS_DEBUG
351 "PacketAlias/Skinny: Not a skinny packet,StartMediaTx Message\n");
355 #ifdef LIBALIAS_DEBUG
357 "PacketAlias/Skinny: Received start media trans msg\n");
359 startmedia_tx = (struct StartMediaTransmission *)&sd->msgId;
360 alias_skinny_startmedia(startmedia_tx, pip, tc, lnk, lip, direction);
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);