m3ua.c000644 000766 000000 00000075767 11271756155 013040 0ustar00bagyendawheel000000 000000 /* * libss7: An implementation of Signalling System 7 * * Written by Paul Bagyenda * * SIGTRAN M3UA over SCTP implementation * * Copyright (C) 2009-, Digital Solutions * All Rights Reserved. */ /* * See http://www.asterisk.org for more information about * the Asterisk project. Please do not directly contact * any of the maintainers of this project for assistance; * the project provides a web site, mailing lists and IRC * channels for your use. * * This program is free software, distributed under the terms of * the GNU General Public License Version 2 as published by the * Free Software Foundation. See the LICENSE file included with * this program for more details. * * In addition, when this program is distributed with Asterisk in * any form that would qualify as a 'combined work' or as a * 'derivative work' (but not mere aggregation), you can redistribute * and/or modify the combination under the terms of the license * provided with that copy of Asterisk, instead of the license * terms granted here. */ #include #include #include #include #include #include "libss7.h" #include "ss7_internal.h" #include "m3ua.h" #include "mtp3.h" #include "isup.h" #ifdef WITH_SCTP #include "netinet/sctp.h" #endif struct m3ua_header { unsigned char ver; unsigned char _reserved; unsigned char msg_class; unsigned char msg_type; unsigned int len; }; struct m3ua_data_header { u_int32_t opc; u_int32_t dpc; u_int8_t si; u_int8_t ni; u_int8_t mp; u_int8_t sls; }; #define M3UA_NET_MSG 0xFF /* impossible user part, used to signal that this is a net message */ #define M3UA_PPID 0x03 /* M3UA SCTP PID val */ #define ROUNDUP(x,n) (((x)+(n)-1) & ~((n)-1)) /* assumes n is power of two */ #define DEFAULT_RETRY_TIMEOUT 2000 struct m3ua *m3ua_new(char *name, unsigned int adjpc) { struct m3ua *m = calloc(1, sizeof *m); if (!m) return NULL; strncpy(m->name, name, sizeof name); m->adjpc = adjpc; m->state = M3UA_ASP_DOWN; m->t1 = -1; m->t2 = -1; m->t3 = -1; return m; } int m3ua_set_routinglabel(unsigned char *sif, struct routing_label *rl) { struct m3ua_data_header *x = (void *)sif; x->opc = htonl(rl->opc); x->dpc = htonl(rl->dpc); x->sls = rl->sls; return 12; } #define COMP_PC(pc1,pc2,mask) (((pc1) ^ (pc2)) & (mask)) /* compare PCs with bits masked off */ static inline int dest_congestion(struct m3ua *link, int dpc) { struct m3ua_congestion *c; for (c = link->con; c; c = c->next) if (COMP_PC(dpc, c->pc, c->mask) == 0) return c->con; return 0; } /* adapted from mtp3.c */ static inline int link_available(struct ss7 *ss7, int linkid, struct routing_label rl) { struct m3ua *m = ss7->m3ua_links[linkid]; if (m && m->state == M3UA_ASP_ACTIVE) { struct m3ua_route *r; if (m->adjpc == rl.dpc) /* Directly linked, report as such */ return 1; /* Check list, if our destination is in there, stop. */ for (r = m->routes; r; r = r->next) if (COMP_PC(r->pc,rl.dpc,r->mask) == 0) /* same in all bits but masked ones */ return r->avail; } return 0; } static inline struct m3ua * rl_to_link(struct ss7 *ss7, struct routing_label rl, int has_sls) { int linkid; linkid = (rl.sls >> ss7->sls_shift) % ss7->num_m3ua_links; if (has_sls && link_available(ss7, linkid, rl)) return ss7->m3ua_links[linkid]; else { struct m3ua *winner = NULL; int i, best; if (has_sls) for (i = 0; i < ss7->num_m3ua_links; i++) { if (link_available(ss7, i, rl)) { winner = ss7->m3ua_links[i]; break; } } else /* Find the one with the least congestion on this destination */ for (i = 0, best = 0; i < ss7->num_m3ua_links; i++) if (link_available(ss7, i, rl)) { int c = dest_congestion(ss7->m3ua_links[i], rl.dpc); if (!winner || c < best) winner = ss7->m3ua_links[i]; } return winner; } } static struct m3ua * rl_to_m3ua_no_check(struct ss7 *ss7, struct routing_label rl) { int i = 0; struct m3ua *link = NULL; for (i = 0; i < ss7->num_m3ua_links; i++) { if (ss7->m3ua_links[i]->slc == rl.sls && (ss7->m3ua_links[i]->adjpc == rl.dpc)) { link = ss7->m3ua_links[i]; break; } } return link; } int m3ua_rl_to_link(struct ss7 *ss7, struct routing_label rl, int userpart, int has_sls, struct ss7_route *rt) { if (ss7->num_m3ua_links == 0) return -1; else if (userpart == SIG_ISUP || userpart == SIG_SCCP) rt->link = rl_to_link(ss7, rl,has_sls); else rt->link = rl_to_m3ua_no_check(ss7, rl); if (rt->link == NULL) return -1; rt->type = M3UA_ROUTE; rt->data = NULL; return 0; } int m3ua_set_sockopts(int fd) { /* Set sctp events flags */ #ifdef WITH_SCTP struct sctp_event_subscribe s = { .sctp_send_failure_event = 1, .sctp_shutdown_event = 1, .sctp_data_io_event = 1, }; return setsockopt(fd, IPPROTO_SCTP, SCTP_EVENTS, &s, sizeof s); #else return -1; #endif } static void down_link(struct m3ua *link); static int m3ua_transmit_int(struct ss7 *ss7, struct m3ua *link, u_int16_t msg_type, u_int8_t sls, struct ss7_msg *m) { struct m3ua_header *hdr = (void *)m->buf; int res; hdr->msg_class = M3UA_MSG_CLASS(msg_type); hdr->msg_type = M3UA_MSG_CODE(msg_type); hdr->len = htonl(m->size + M3UA_COMMON_HLEN); hdr->ver = 1; #ifdef WITH_SCTP res = sctp_sendmsg(link->fd, m->buf, m->size + M3UA_COMMON_HLEN, NULL, 0, M3UA_PPID, 0, sls, 0, 0); if (res < 0) { /* Close connection? If no associations */ uint32_t n = 0; socklen_t x = sizeof n; if (getsockopt(link->fd, IPPROTO_SCTP, SCTP_GET_ASSOC_NUMBER, &n, &x) == 0 && n<=0) link->state = M3UA_ASP_DOWN; /* But don't down_link() since caller might do that. */ } #else ss7_error(ss7, "No M3UA support (SCTP implementation missing!\n"); res = -1; #endif free(m); return res; } #define add_tlv(p,tag,val,len) do { \ u_int16_t *_t = (void *)(p); \ u_int32_t _len = (len)+2*sizeof _t[0]; \ _t[0] = htons(tag); \ _t[1] = htons(_len); /*incl. len of tl part */ \ memcpy(((char *)(p)) + 2*sizeof _t[0], (val), (len)); \ _len = ROUNDUP(_len,4); \ _t += _len/sizeof _t[0]; /* Skip to end */ \ (p) = (void *)_t; \ } while (0) int m3ua_transmit_ex(struct ss7 *ss7, struct ss7_route rt, unsigned int userpart, int priority, int corrid, struct ss7_msg *m) { struct m3ua *link = rt.link; if (link) { /* Fix up message: headers and so forth */ struct m3ua_data_header *dhr = (void *)(m->buf + M3UA_COMMON_HLEN + M3UA_DATA_HLEN); u_int16_t *s = (u_int16_t *)(m->buf + M3UA_COMMON_HLEN); u_int32_t cid = (corrid >= 0) ? corrid : link->fd; unsigned char *p; s[0] = htons(0x0210); /* Tag for data param */ s[1] = htons(m->size); /* already includes length of tlv (before padding) */ dhr->mp = priority; dhr->ni = ss7->ni; dhr->si = userpart & 0xFF; /* indicate user part. */ m->size = ROUNDUP(m->size, 4); /* Add padding. XXX assumes allocator cleared the mem. */ p = (void *)(m->buf + M3UA_COMMON_HLEN + m->size); /* Now add correlation ID */ add_tlv(p, 0x0013, &cid, sizeof cid); m->size += 8; /* added correlation TLV */ return m3ua_transmit_int(ss7, link, M3UA_DATA_MSG, rt.sls, m); } else { ss7_error(ss7, "No signalling link available sending message!\n"); free(m); return -1; } } void m3ua_free(struct m3ua *m) { struct m3ua_route *x; if (!m) return; while (m->routes) { x = m->routes; m->routes = m->routes->next; free(x); } while (m->keys) { struct m3ua_routing_key *x = m->keys; m->keys = m->keys->next; free(x); } free(m); } /* Remove a link completely, assume we are locked */ static void remove_link(struct m3ua *link) { struct ss7 *ss7 = link->master; int i; ss7_schedule_del(ss7, &link->t1); ss7_schedule_del(ss7, &link->t2); ss7_schedule_del(ss7, &link->t3); for (i = 0; inum_m3ua_links; i++) if (ss7->m3ua_links[i] == link) { int nobjs = ss7->num_m3ua_links-i-1; ss7_event *e; if (nobjs > 0) /* remove it */ memmove(&ss7->m3ua_links[i], &ss7->m3ua_links[i + 1], nobjs*sizeof ss7->m3ua_links[0]); ss7->num_m3ua_links--; /* Inform upper layer of shutdown and delete this puppy */ e = ss7_next_empty_event(ss7); if (e) { e->e = M3UA_LINK_DOWN; e->gen.data = link->fd; } m3ua_free(link); break; } } #define DOWN_RETRIES 5 /* Attempt to bring a link down gracefully */ static void down_link(struct m3ua *link) { struct ss7_msg *m; if (!link) return; ss7_schedule_del(link->master, &link->t3); /* Cancel any pending */ ss7_schedule_del(link->master, &link->t2); ss7_schedule_del(link->master, &link->t1); if (link->state == M3UA_ASP_DOWN) goto free_link; m = ss7_msg_new(); if (m) { unsigned char *p = m->buf + M3UA_COMMON_HLEN, *q = p; int msg = -1; if (link->down_ctr > DOWN_RETRIES) /* handle retries timeout issue. */ link->state = (link->state == M3UA_ASP_IA_SENT) ? M3UA_ASP_INACTIVE : M3UA_ASP_DOWN; if (link->state != M3UA_ASP_DOWN) { /* send a notification and wait. */ char buf[32]; int len = sprintf(buf, "%d", link->fd); add_tlv(p, 0x0004, buf, len); msg = (link->state == M3UA_ASP_ACTIVE) ? M3UA_ASPIA_MSG : M3UA_ASPDN_MSG; link->state = (link->state == M3UA_ASP_ACTIVE) ? M3UA_ASP_IA_SENT : M3UA_ASP_DOWN_SENT; m->size = p - q; } else link->state = M3UA_ASP_DOWN; if (msg >= 0) { int res = m3ua_transmit_int(link->master, link, msg, link->master->sls, m); if (res > 0) link->down_ctr++; /* Keep count of how many times we've sent this */ if (res < 0) link->state = M3UA_ASP_DOWN; else if (link->state != M3UA_ASP_DOWN) link->t3 = ss7_schedule_event(link->master, DEFAULT_RETRY_TIMEOUT*2, (void *)down_link, link); } else if (m) free(m); } free_link: if (link->state == M3UA_ASP_DOWN) /* bring it down */ remove_link(link); } static void transmit_aspup(void *x) { struct m3ua *link = x; struct ss7_msg *m = ss7_msg_new(); u_int32_t aspid = link->fd; unsigned char *p, *q; int res; if (!m) { ss7_error(link->master, "Allocation failed!\n"); return; } p = q = m->buf + M3UA_COMMON_HLEN; add_tlv(p, 0x0011, &aspid, sizeof(aspid)); m->size = p - q; res = m3ua_transmit_int(link->master, link, M3UA_ASPUP_MSG, 1, m); if (res > 0) { link->state = M3UA_ASP_UP_SENT; /* Set retry timer. */ link->t1 = ss7_schedule_event(link->master, DEFAULT_RETRY_TIMEOUT, (void *)transmit_aspup, link); } else if (res < 0 && errno != EAGAIN && errno != EINTR) { /* close the connection */ link->t1 = -1; down_link(link); } } static void transmit_aspac(void *x) { struct m3ua *link = x; struct ss7_msg *m; char aspid[32]; unsigned char *p, *q; int res, len; if (!link || link->state != M3UA_ASP_UP) return; m = ss7_msg_new(); if (!m) { ss7_error(link->master, "Allocation failed!\n"); return; } len = sprintf(aspid, "%d", link->fd); p = q = m->buf + M3UA_COMMON_HLEN; add_tlv(p, 0x0004, aspid, len); m->size = p - q; res = m3ua_transmit_int(link->master, link, M3UA_ASPAC_MSG, 1, m); if (res > 0) { link->state = M3UA_ASP_AC_SENT; /* Set retry timer. */ link->t2 = ss7_schedule_event(link->master, DEFAULT_RETRY_TIMEOUT, (void *)transmit_aspac, link); } else if (res < 0 && errno != EAGAIN && errno != EINTR) { /* close the connection */ link->t2 = -1; down_link(link); /* try and bring it down gracefully */ } } void m3ua_start(struct ss7 *ss7) { int i; for (i = 0; inum_m3ua_links; i++) if (ss7->m3ua_links[i]->state == M3UA_ASP_DOWN) transmit_aspup(ss7->m3ua_links[i]); } #define NEXT_TAG(tptr) ROUNDUP(ntohs((tptr)[1]), 4)/2 /* round up length, then jump over tlv. */ static inline void *find_param(void *v, int tag, int lim, int *dlen) { unsigned char *p = v; u_int16_t *u = (void *)p; while ((void *)u < (void *)(p + lim)) if (ntohs(u[0]) == tag) { /* Data element */ *dlen = ntohs(u[1]) - 2*sizeof u[0]; /* Remove length of TL part */ return u + 2; } else u += NEXT_TAG(u); /* Skip TLV */ return NULL; } static int transmit_rkm_reg(struct m3ua *link); static int net_msg_recv(struct ss7*, struct m3ua *, struct m3ua_header *, int len, char errbuf[]); int m3ua_receive(struct m3ua *link) { struct ss7 *ss7 = link->master; unsigned char buf[1024]; int flags = MSG_WAITALL, len, ppid, streamid; #ifdef WITH_SCTP struct sockaddr addr; socklen_t alen = sizeof addr; struct sctp_sndrcvinfo sinfo; len = sctp_recvmsg(link->fd, buf, sizeof buf, &addr, &alen, &sinfo, &flags); ppid = ntohl(sinfo.sinfo_ppid); streamid = ntohl(sinfo.sinfo_stream); if (len <= 0) { /* Close connection? If no associations */ uint32_t n = 0; socklen_t x = sizeof n; if (getsockopt(link->fd, IPPROTO_SCTP, SCTP_GET_ASSOC_NUMBER, &n, &x) == 0 && n<=0) { link->state = M3UA_ASP_DOWN; len = -1; } } #else len = -1; ppid = -1; ss7_error(ss7, "M3UA read: No SCTP support!\n"); #endif if (len <= 0) /* Nothing read */ return len; if (flags & MSG_NOTIFICATION) { #ifdef WITH_SCTP union sctp_notification *sn = (void *)buf; switch(sn->sn_header.sn_type) { case SCTP_SEND_FAILED: /* Pass correlation ID upwards */ { int dlen; u_int32_t *i = find_param(sn->sn_send_failed.ssf_data, 0x0013, sn->sn_send_failed.ssf_length, &dlen); /* find correlation ID */ if (i) { ss7_event *e = ss7_next_empty_event(ss7); if (e) { e->e = M3UA_SEND_FAILED; e->gen.data = ntohl(i[0]); } } } break; case SCTP_SHUTDOWN_EVENT: /* we should do something if this is the last assoc. right? */ break; default: break; /* do nothing. */ } #endif return 0; } else if ((flags & MSG_EOR) && len >= M3UA_COMMON_HLEN #if 1 && ppid == M3UA_PPID #endif ) { /* Data */ struct m3ua_header *hdr = (void *)buf; int err_code = -1; char errbuf[64]; errbuf[0] = 0; if (hdr->ver != 0x01) /* unsupported version. */ err_code = 0x01; else if (hdr->msg_class == M3UA_TRANSFER_CLASS) { if (hdr->msg_type != 0x01) err_code = 0x04; else { /* Find the protocol data element */ int dlen = 0; struct m3ua_data_header *dhr; dhr = find_param(hdr + 1, 0x0210, len - sizeof hdr[0], &dlen); if (dhr) { struct routing_label rl = {.opc = ntohl(dhr->opc), .dpc = ntohl(dhr->dpc), .sls = dhr->sls}; int ecode = 0; dlen -= sizeof dhr[0]; switch(dhr->si) { case SIG_ISUP: ecode = isup_receive(ss7, &rl, (void *)(dhr + 1), dlen); break; case SIG_SCCP: default: if (ss7_userpart_receive(ss7, rl, dhr->si, dhr + 1, dlen) < 0) ecode = 0x06; break; } if (ecode < 0) { err_code = 0x07; /* Protocol error */ sprintf(errbuf, "M3UA User 0x%02X returned error: %d", dhr->si, ecode); } } else { /* Failed to decode message */ sprintf(errbuf, "Missing data param in TRANSFER message"); err_code = 0x16; /* Missing parameter (data) */ } } } else if (hdr->msg_class == M3UA_MGMT_CLASS || hdr->msg_class == M3UA_ASPSM_CLASS || hdr->msg_class == M3UA_ASPTM_CLASS || hdr->msg_class == M3UA_SSNM_CLASS || hdr->msg_class == M3UA_RKM_CLASS) err_code = net_msg_recv(ss7, link, hdr, len, errbuf); else err_code = 0x03; if (err_code > 0) { struct ss7_msg *m = ss7_msg_new(); if (m) { unsigned char *p = m->buf + M3UA_COMMON_HLEN, *q = p; u_int32_t err = htonl(err_code); int sl = strlen(errbuf); add_tlv(p, 0x000c, &err, sizeof err); if (sl > 0) add_tlv(p, 0x0007, errbuf, sl); m->size = p - q; return m3ua_transmit_int(ss7, link, M3UA_ERR_MSG, streamid,m); } else ss7_error(ss7, "M3UA read: Allocation failed!\n"); return -1; } else return err_code; /* no errors */ } else { ss7_error(ss7, "M3UA read: Unexpected message, skipped!\n"); return -1; } } static inline struct m3ua *find_m3ua_link(struct ss7 *ss7, int fd) { int i; for (i = 0; inum_m3ua_links; i++) if (ss7->m3ua_links[i] && ss7->m3ua_links[i]->fd == fd) return ss7->m3ua_links[i]; return NULL; } static const char *m3ua_errors[] = { [0x01] = "Invalid Version", [0x02] = "Not Used in M3UA", [0x03] = "Unsupported Message Class", [0x04] = "Unsupported Message Type", [0x05] = "Unsupported Traffic Mode Type", [0x06] = "Unexpected Message", [0x07] = "Protocol Error", [0x08] = "Not Used in M3UA", [0x09] = "Invalid Stream Identifier", [0x0a] = "Not Used in M3UA", [0x0b] = "Not Used in M3UA", [0x0c] = "Not Used in M3UA", [0x0d] = "Refused - Management Blocking", [0x0e] = "ASP Identifier Required", [0x0f] = "Invalid ASP Identifier", [0x10] = "Not Used in M3UA", [0x11] = "Invalid Parameter Value", [0x12] = "Parameter Field Error", [0x13] = "Unexpected Parameter", [0x14] = "Destination Status Unknown", [0x15] = "Invalid Network Appearance", [0x16] = "Missing Parameter", [0x17] = "Not Used in M3UA", [0x18] = "Not Used in M3UA", [0x19] = "Invalid Routing Context", [0x1a] = "No Configured AS for ASP", }; static int net_msg_recv(struct ss7 *ss7, struct m3ua *link, struct m3ua_header *hdr, int len, char errbuf[]) { int *i, dlen = 0; unsigned char *s; struct ss7_msg *m; int type = M3UA_MSG(hdr->msg_class,hdr->msg_type); switch (type) { case M3UA_ASPUP_ACK_MSG: if ((i = find_param(hdr + 1, 0x0011, len - sizeof hdr[0], &dlen)) != NULL) { /* Find ASP ID */ link = find_m3ua_link(ss7, *i); if (!link) return 0x07; /* protocol error: no such ASP */ } else if (link->state > M3UA_ASP_ACTIVE) return 0x06; if (link->state == M3UA_ASP_UP_SENT) { ss7_schedule_del(ss7, &link->t1); link->state = M3UA_ASP_UP; /* We are officially UP but not active */ if (link->keys) transmit_rkm_reg(link); /* Send reg requests, wait for response before we go active*/ else transmit_aspac(link); } /* else ignore (possible duplicate) */ break; case M3UA_ASPAC_ACK_MSG: if ((s = find_param(hdr + 1, 0x0004, len - sizeof hdr[0], &dlen)) != NULL) { /* Find ASP ID */ struct m3ua *xlink = link; int fd = -1; sscanf((void *)s, "%d", &fd); xlink = find_m3ua_link(ss7, fd); if (xlink) link = xlink; /* Assume it's broken and use current? XXX */ } if (link->state == M3UA_ASP_AC_SENT) { ss7_event *e; ss7_schedule_del(ss7, &link->t2); link->state = M3UA_ASP_ACTIVE; /* Success! */ e = ss7_next_empty_event(ss7); if (e) { e->e = M3UA_LINK_UP; e->gen.data = link->fd; } } else if (link->state < M3UA_ASP_AC_SENT) return 0x06; /* unexpected message */ break; case M3UA_ASPIA_ACK_MSG: if ((s = find_param(hdr + 1, 0x0004, len - sizeof hdr[0], &dlen)) != NULL) { /* Find ASP ID */ struct m3ua *xlink = link; int fd = -1; sscanf((void *)s, "%d", &fd); xlink = find_m3ua_link(ss7, fd); if (xlink) link = xlink; /* Assume it's broken and use current? XXX */ } if (link->state == M3UA_ASP_IA_SENT) { /* process of going down, complete it */ link->state = M3UA_ASP_INACTIVE; link->down_ctr = 0; /* reset count */ down_link(link); } else if (link->state < M3UA_ASP_IA_SENT) return 0x06; /* unexpected */ break; case M3UA_BEAT_MSG: /* Shouldn't be ordinarily received when using SCTP, but lets handle it all the same */ if ((m = ss7_msg_new()) != NULL) { int dlen = 0; unsigned char *p = m->buf + M3UA_COMMON_HLEN, *q = p; unsigned char *h = find_param(hdr + 1, 0x0009, len - sizeof hdr[0], &dlen); if (h) add_tlv(p, 0x0009, h, dlen); m->size = p - q; m3ua_transmit_int(ss7, link, M3UA_BEAT_ACK_MSG, 1, m); } else ss7_error(ss7, "M3UA read: Allocation failed!\n"); break; case M3UA_ERR_MSG: if ((i = find_param(hdr + 1, 0x000c, len - sizeof hdr[0], &dlen)) != NULL) { /* Find error ID */ int id = ntohl(*i); char buf[256]; sprintf(buf, "M3UA read: Received Error packet: %02X => %.100s!\n", id, (id >= 0 && id < (sizeof m3ua_errors) / sizeof m3ua_errors[0]) ? m3ua_errors[id] : "n/a"); ss7_error(ss7, buf); } break; case M3UA_SCON_MSG: /* Find congestion value */ if ((s = find_param(hdr + 1, 0x0205, len - sizeof hdr[0], &dlen)) != NULL) { u_int8_t con = s[3]; /* find affected PCs, handle appropriately. */ s = (void *)(hdr + 1); while ((s = find_param(s, 0x0012, len - (s - (unsigned char *)hdr), &dlen)) != NULL) { u_int8_t mask = s[0]; u_int32_t afpc, inv_mask; struct m3ua_congestion **c, *new; s[0] = 0; /* clear it before we convert affected pc */ afpc = ntohl(*(u_int32_t *)s); s[0] = mask; /* really necessary ?? */ if (ss7->switchtype == SS7_ANSI && mask > 24) mask = 24; else if (ss7->switchtype == SS7_ITU && mask > 14) mask = 14; /* invert mask: That is, top bits a 1, wildcarded ones zero. This will be ANDed... */ inv_mask = ~((1U<con; *c; ) if (COMP_PC(afpc,(*c)->pc,inv_mask) == 0 && inv_mask <= (*c)->mask) { /* i.e. new one is at least as general as old one */ struct m3ua_congestion *x = (*c); (*c) = (*c)->next; free(x); /* remove it */ } else c = &(*c)->next; /* Add a new one */ new = calloc(1, sizeof new[0]); new->pc = afpc; new->mask = inv_mask; new->con = con; new->next = link->con; link->con = new; s += sizeof(u_int32_t); /* Skip over value */ } } else return 0x16; /* missing parameter */ break; case M3UA_DUNA_MSG: case M3UA_DRST_MSG: case M3UA_DAVA_MSG: /* handled the same, save for availability flag */ s = find_param(hdr + 1, 0x0012, len - sizeof hdr[0], &dlen); if (s) while (dlen > 0) { u_int8_t mask = s[0]; u_int32_t afpc, inv_mask; struct m3ua_route **r, *new; s[0] = 0; /* clear it before we convert affected pc */ afpc = ntohl(*(u_int32_t *)s); s[0] = mask; /* really necessary ?? */ if (ss7->switchtype == SS7_ANSI && mask > 24) mask = 24; else if (ss7->switchtype == SS7_ITU && mask > 14) mask = 14; /* invert mask: That is, top bits a 1, wildcarded ones zero. This will be ANDed... */ inv_mask = ~((1U<routes; *r; ) if (COMP_PC(afpc,(*r)->pc,inv_mask) == 0 && inv_mask <= (*r)->mask) { /* i.e. new one is at least as general as old one */ struct m3ua_route *x = (*r); (*r) = (*r)->next; free(x); } else r = &(*r)->next; /* Add a new one */ new = calloc(1, sizeof new[0]); new->pc = afpc; new->mask = inv_mask; new->avail = (type == M3UA_DAVA_MSG) ? 1 : 0; new->next = link->routes; link->routes = new; dlen -= sizeof(u_int32_t); /* Skip over value */ s += sizeof (u_int32_t); } break; case M3UA_DUPU_MSG: if ((i = find_param(hdr + 1, 0x0012, len - sizeof hdr[0], &dlen)) != NULL) { u_int32_t afpc = ntohl(*i); u_int16_t *u = find_param(hdr + 1, 0x0204, len - sizeof hdr[0], &dlen); ss7_event *e; if (!u) return 0x16; e = ss7_next_empty_event(ss7); if (e) { u_int8_t userpart = (u_int8_t)ntohs(u[1]); /* ignore cause */ e->e = M3UA_DUPU; e->gen.arg = userpart; e->gen.data = afpc; } } else return 0x16; break; case M3UA_RKM_REG_RSP_MSG: s = (void *)(hdr + 1); while ((s = find_param(s, 0x0208, len - (s - (unsigned char *)hdr), &dlen)) != NULL) { int x; u_int32_t *i = find_param(s, 0x020a, dlen, &x); /* find local identifier */ u_int32_t status, rc, rki = i ? *i : 0; if ((i = find_param(s, 0x0212, dlen, &x)) != NULL) status = ntohl(*i); else status = 1; if ((i = find_param(s, 0x006, dlen, &x)) != NULL) rc = ntohl(*i); else rc = 0; if (rki) { ss7_event *e; struct m3ua_routing_key **l = &link->keys, *x; int found = 0; while (*l) { if ((*l)->rk.rki == rki) { if (status == 0) { (*l)->active = 1; (*l)->rc = rc; found = 1; } else { /* Delete it */ x = *l; *l = (*l)->next; free(x); continue; } } l = &(*l)->next; } /* At least one routing context, lets send ACTIVE ind. */ if (found && status == 0 && link->state == M3UA_ASP_UP) transmit_aspac(link); /* Inform upper level */ e = ss7_next_empty_event(ss7); if (e) { e->e = M3UA_ROUTE_REG_RSP; e->gen.arg = rki; e->gen.data = status; } } s += dlen; } break; case M3UA_RKM_DEREG_RSP_MSG: s = (void *)(hdr + 1); while ((s = find_param(s, 0x0209, len - (s - (unsigned char *)hdr), &dlen)) != NULL) { int x; u_int32_t *i = find_param(s, 0x0006, dlen, &x); /* find RC */ u_int32_t status, rc = i ? ntohl(*i) : 0, rki = 0; ss7_event *e; struct m3ua_routing_key **l = &link->keys; if ((i = find_param(s, 0x0213, dlen, &x)) != NULL) status = ntohl(*i); else status = 1; while (*l) { /* Find the corresponding key, remove it. */ if ((*l)->rc == rc) { struct m3ua_routing_key *x = *l; rki = x->rk.rki; *l = (*l)->next; continue; } l = &(*l)->next; } /* Inform upper level */ e = ss7_next_empty_event(ss7); if (e) { e->e = M3UA_ROUTE_DEREG_RSP; e->gen.arg = rki; e->gen.data = status; } } break; case M3UA_ASPDN_ACK_MSG: if ((s = find_param(hdr + 1, 0x0004, len - sizeof hdr[0], &dlen)) != NULL) { /* Find ASP ID */ struct m3ua *xlink = link; int fd = -1; sscanf((void *)s, "%d", &fd); xlink = find_m3ua_link(ss7, fd); if (xlink) link = xlink; /* Assume it's broken and use current? XXX */ } if (link->state == M3UA_ASP_DOWN_SENT) { /* process of going down, complete it */ link->state = M3UA_ASP_DOWN; link->down_ctr = 0; /* reset count */ down_link(link); } break; case M3UA_BEAT_ACK_MSG: case M3UA_NTY_MSG: case M3UA_ASPUP_MSG: case M3UA_ASPDN_MSG: case M3UA_ASPAC_MSG: case M3UA_ASPIA_MSG: case M3UA_RKM_REG_REQ_MSG: case M3UA_RKM_DEREG_REQ_MSG: return 0; /* Ignore */ break; default: return 0x04; /* unsupported message. */ break; } return 0; } /* Computes length of routing key, so we don't overflow message buffer */ static inline int sizeof_rk(struct m3ua_routing_key_req *r) { int len = 8 + 8; /* Local RK-Id value length + dpc length*/ if (r->traffic_mode >= 1 && r->traffic_mode <= 3) len += 8; if (r->net_app >= 0) len += 8; if (r->si_list.n > 0) len += ROUNDUP(r->si_list.n,4) + 4; if (r->opc_list.n > 0) len += 4 + r->opc_list.n*4; if (r->cic_list.n > 0) len += r->cic_list.n*8 + 4; return len; } static int transmit_rkm_reg(struct m3ua *link) { struct m3ua_routing_key *rk; struct ss7 *ss7 = link->master; if (link->state == M3UA_ASP_DOWN || link->state == M3UA_ASP_IA_SENT || link->state == M3UA_ASP_DOWN_SENT) return -1; if (link->state != M3UA_ASP_UP && link->state != M3UA_ASP_ACTIVE) return 0; for (rk = link->keys; rk; rk = rk->next) if (rk->sent == 0) { struct m3ua_routing_key_req rk1 = rk->rk; u_int16_t *u, rlen; unsigned char *s; u_int32_t x; struct ss7_msg *m; unsigned char *q; int res; m = ss7_msg_new(); if (!m) { ss7_error(ss7, "M3UA send rkm: Allocation failed!\n"); return -1; } q = m->buf + M3UA_COMMON_HLEN; u = (void *)q; s = q + 2*sizeof u[0]; /* leave space for Routing key T & L */ add_tlv(s, 0x020a, &rk1.rki, sizeof rk1.rki); if (rk1.traffic_mode > 0 && rk1.traffic_mode <= 3) { rk1.traffic_mode = htonl(rk1.traffic_mode); add_tlv(s, 0x000b, &rk1.traffic_mode, 4); } x = htonl(ss7->pc); /* add destination as our PC */ add_tlv(s, 0x020b, &x, sizeof x); if (rk1.net_app>0) { rk1.net_app = htonl(rk1.net_app); add_tlv(s, 0x0200, &rk1.net_app, 4); } if (rk1.si_list.n > 0) add_tlv(s, 0x020c, rk1.si_list.si, rk1.si_list.n); if (rk1.opc_list.n > 0) { int j; for (j = 0; j 0) { int j; for (j = 0; jsize = rlen; res = m3ua_transmit_int(ss7, link, M3UA_RKM_REG_REQ_MSG, 1, m); if (res > 0) rk->sent = 1; } return 0; } int m3ua_rkm_reg(struct ss7 *ss7, struct routing_label rl, struct m3ua_routing_key_req rk[], int num_keys) { struct m3ua *link = rl_to_m3ua_no_check(ss7, rl); int i; if (!link || !rk) return -1; for (i = 0; i < num_keys; i++) if (sizeof_rk(&rk[i]) < M3UA_COMMON_HLEN + 4 + sizeof ((struct ss7_msg *)0)->buf) { struct m3ua_routing_key *r; r = calloc(1, sizeof r[0]); if (!r) { ss7_error(ss7, "M3UA rkm reg: Allocation failed!\n"); return -1; } r->rk = rk[i]; r->rk.rki = rk[i].rki = (u_int32_t)r; r->active = 0; r->sent = 0; r->next = link->keys; /* put it in */ link->keys = r; } else rk[i].rki = 0; return transmit_rkm_reg(link); } int m3ua_rkm_dereg(struct ss7 *ss7, struct routing_label rl, u_int32_t rki[], int num_keys) { struct m3ua_routing_key *kl; struct m3ua *link = rl_to_m3ua_no_check(ss7, rl); struct ss7_msg *m; unsigned char *p; u_int16_t *s; u_int32_t *u; int i; if (!link) return -1; m = ss7_msg_new(); if (!m) return -1; p = m->buf + M3UA_COMMON_HLEN; s = (void *)p; for (i = 0, u = (void *)(p+4); ibuf + sizeof m->buf; i++) for (kl = link->keys; kl; kl = kl->next) if (kl->rk.rki == rki[i]) { /* Find the key, use the routin context from it. */ *u = htonl(kl->rc); u++; } m->size = 4 + (unsigned char *)u - p; s[0] = htons(0x0006); s[1] = htons(m->size); return m3ua_transmit_int(ss7, link, M3UA_RKM_DEREG_REQ_MSG, 1, m); } void m3ua_down_link(struct ss7 *ss7, int fd) { struct m3ua *link = find_m3ua_link(ss7, fd); if (link) down_link(link); } int m3ua_daud(struct ss7 *ss7, struct routing_label rl, int na, int rc, int dpc, char *info) { struct ss7_msg *m; struct m3ua *link = rl_to_m3ua_no_check(ss7, rl); unsigned char *p, *s; u_int32_t x; if (!link) return -1; m = ss7_msg_new(); if (!m) return -1; p = s = m->buf + M3UA_COMMON_HLEN; if (na >= 0) { x = htonl(na); add_tlv(s, 0x0200, &x, sizeof x); } if (rc >= 0) { x = htonl(rc); add_tlv(s, 0x0006, &x, sizeof x); } x = htonl(dpc); add_tlv(s, 0x0012, &x, sizeof x); if (info) add_tlv(s, 0x0004, info, strlen(info)); m->size = s - p; return m3ua_transmit_int(ss7, link, M3UA_DAUD_MSG, 1, m); } m3ua.h000644 000766 000000 00000014014 11271756155 013017 0ustar00bagyendawheel000000 000000 /* * libss7: An implementation of Signalling System 7 * * Written by Paul Bagyenda * * SIGTRAN M3UA over SCTP implementation * * Copyright (C) 2009-, Digital Solutions * All Rights Reserved. */ /* * See http://www.asterisk.org for more information about * the Asterisk project. Please do not directly contact * any of the maintainers of this project for assistance; * the project provides a web site, mailing lists and IRC * channels for your use. * * This program is free software, distributed under the terms of * the GNU General Public License Version 2 as published by the * Free Software Foundation. See the LICENSE file included with * this program for more details. * * In addition, when this program is distributed with Asterisk in * any form that would qualify as a 'combined work' or as a * 'derivative work' (but not mere aggregation), you can redistribute * and/or modify the combination under the terms of the license * provided with that copy of Asterisk, instead of the license * terms granted here. */ #ifndef _M3UA_H #define _M3UA_H /* Message classes */ #define M3UA_MGMT_CLASS 0x00 #define M3UA_TRANSFER_CLASS 0x01 #define M3UA_SSNM_CLASS 0x02 #define M3UA_ASPSM_CLASS 0x03 #define M3UA_ASPTM_CLASS 0x04 #define M3UA_RKM_CLASS 0x09 #define M3UA_MSG(cls,code) (((cls)<<8)|(code)) #define M3UA_MSG_CODE(msg) ((msg) & 0xFF) #define M3UA_MSG_CLASS(msg) (((msg)>>8) & 0xFF) /* Messages */ #define M3UA_ERR_MSG M3UA_MSG(M3UA_MGMT_CLASS,0x00) #define M3UA_NTY_MSG M3UA_MSG(M3UA_MGMT_CLASS,0x01) #define M3UA_DATA_MSG M3UA_MSG(M3UA_TRANSFER_CLASS,0x01) #define M3UA_DUNA_MSG M3UA_MSG(M3UA_SSNM_CLASS,0x01) #define M3UA_DAVA_MSG M3UA_MSG(M3UA_SSNM_CLASS,0x02) #define M3UA_DAUD_MSG M3UA_MSG(M3UA_SSNM_CLASS,0x03) #define M3UA_SCON_MSG M3UA_MSG(M3UA_SSNM_CLASS,0x04) #define M3UA_DUPU_MSG M3UA_MSG(M3UA_SSNM_CLASS,0x05) #define M3UA_DRST_MSG M3UA_MSG(M3UA_SSNM_CLASS,0x06) #define M3UA_ASPUP_MSG M3UA_MSG(M3UA_ASPSM_CLASS,0x01) #define M3UA_ASPDN_MSG M3UA_MSG(M3UA_ASPSM_CLASS,0x02) #define M3UA_BEAT_MSG M3UA_MSG(M3UA_ASPSM_CLASS,0x03) #define M3UA_ASPUP_ACK_MSG M3UA_MSG(M3UA_ASPSM_CLASS,0x04) #define M3UA_ASPDN_ACK_MSG M3UA_MSG(M3UA_ASPSM_CLASS,0x05) #define M3UA_BEAT_ACK_MSG M3UA_MSG(M3UA_ASPSM_CLASS,0x06) #define M3UA_ASPAC_MSG M3UA_MSG(M3UA_ASPTM_CLASS,0x01) #define M3UA_ASPIA_MSG M3UA_MSG(M3UA_ASPTM_CLASS,0x02) #define M3UA_ASPAC_ACK_MSG M3UA_MSG(M3UA_ASPTM_CLASS,0x03) #define M3UA_ASPIA_ACK_MSG M3UA_MSG(M3UA_ASPTM_CLASS,0x04) #define M3UA_RKM_REG_REQ_MSG M3UA_MSG(M3UA_RKM_CLASS, 1) #define M3UA_RKM_REG_RSP_MSG M3UA_MSG(M3UA_RKM_CLASS, 2) #define M3UA_RKM_DEREG_REQ_MSG M3UA_MSG(M3UA_RKM_CLASS, 3) #define M3UA_RKM_DEREG_RSP_MSG M3UA_MSG(M3UA_RKM_CLASS, 4) /* Header length for DATA packet: We assume no routing context and no NA params (RFC 3332, pg 32 */ #define M3UA_COMMON_HLEN 8 #define M3UA_DATA_HLEN 4 #define M3UA_MAX_LEN 10 struct m3ua_route { unsigned int pc; /* The referenced destination point code */ unsigned int mask; /* Affected bits in dpc: inverse mask as ~((1< * * * * Copyright (C) 2009-, Digital Solutions * All Rights Reserved. */ /* * See http://www.asterisk.org for more information about * the Asterisk project. Please do not directly contact * any of the maintainers of this project for assistance; * the project provides a web site, mailing lists and IRC * channels for your use. * * This program is free software, distributed under the terms of * the GNU General Public License Version 2 as published by the * Free Software Foundation. See the LICENSE file included with * this program for more details. * * In addition, when this program is distributed with Asterisk in * any form that would qualify as a 'combined work' or as a * 'derivative work' (but not mere aggregation), you can redistribute * and/or modify the combination under the terms of the license * provided with that copy of Asterisk, instead of the license * terms granted here. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "libss7.h" #include "ss7_internal.h" #include "m3ua.h" #ifdef WITH_SCTP #include #endif #define MAX_ADDRESSES 100 static int opc, dpc, linknum = 1; static int callcount = 0; struct linkset { struct ss7 *ss7; int linkno; int fd; } linkset[2]; struct m3ua_routing_key_req rk = { .traffic_mode = 2, .net_app = -1, .si_list = { .n = 3, .si = {3,5} }, .opc_list = { .n = 5, .pc = {1,2,3,4,5} }, .cic_list = { .n = 2, .range = { {.opc = 1, .lower = 1, .upper = 2 }, {.opc = 2, .lower = 3, .upper = 4 }} } }; static void myprintf(struct ss7 *ss7, char *fmt) { //int i = 0; printf("%s", fmt); } static void print_args(void) { printf("Incorrect arguments. Should be:\n"); printf("m3uatest dest-ip[:port][,dest-ip2[:port] ...] [OPC - in decimal] [DPC - in decimal]\n"); printf("Example:\n"); printf("m3uatest 127.0.0.1:2905 1 2\n"); printf("This would run the test program, connecting to the SGP on port 2905 at localhost with an OPC of 1 and a DPC of 2\n"); } static void ss7_call(struct ss7 *ss7) { struct isup_call *c; c = isup_new_call(ss7); if (c) { isup_set_called(c, "12345", SS7_NAI_NATIONAL, ss7); isup_set_calling(c, "7654321", SS7_NAI_NATIONAL, SS7_PRESENTATION_ALLOWED, SS7_SCREENING_USER_PROVIDED); isup_init_call(ss7, c, (callcount % 12) + 1, dpc); isup_iam(ss7, c); printf("Callcount = %d\n ", ++callcount); } } static void *ss7_run(void *data) { struct linkset *linkset = data; struct ss7 *ss7 = linkset->ss7; int res = 0; struct timeval *next = NULL, tv; ss7_event *e = NULL; struct pollfd poller; int nextms = 2000; struct isup_call *c; unsigned char state[255] = {0}; struct routing_label rl = {.type = ss7->switchtype, .dpc = dpc, .opc = opc, .sls=1}; u_int32_t rkm[] = {rk.rki}; printf("Starting link %d\n", ++linknum); ss7_start(ss7); while(1) { if ((next = ss7_schedule_next(ss7))) { gettimeofday(&tv, NULL); tv.tv_sec = next->tv_sec - tv.tv_sec; tv.tv_usec = next->tv_usec - tv.tv_usec; if (tv.tv_usec < 0) { tv.tv_usec += 1000000; tv.tv_sec -= 1; } if (tv.tv_sec < 0) { tv.tv_sec = 0; tv.tv_usec = 0; } nextms = tv.tv_sec * 1000; nextms += tv.tv_usec / 1000; } poller.fd = linkset->fd; poller.events = ss7_pollflags(ss7, linkset->fd); poller.revents = 0; res = poll(&poller, 1, nextms); if (res < 0) { #if 0 printf("next->tv_sec = %d\n", next->tv_sec); printf("next->tv_usec = %d\n", next->tv_usec); printf("tv->tv_sec = %d\n", tv.tv_sec); printf("tv->tv_usec = %d\n", tv.tv_usec); #endif perror("select"); } else if (!res) { ss7_schedule_run(ss7); continue; } #if 0 if (poller.revents & POLLPRI) { if (ioctl(linkset->fd, DAHDI_GETEVENT, &x)) { perror("Error in exception retrieval!\n"); } switch (x) { case DAHDI_EVENT_OVERRUN: printf("Overrun detected!\n"); break; case DAHDI_EVENT_BADFCS: printf("Bad FCS!\n"); break; case DAHDI_EVENT_ABORT: printf("HDLC Abort!\n"); break; default: printf("Got exception %d!\n", x); break; } } #endif if (poller.revents & POLLIN) res = ss7_read(ss7, linkset->fd); if (poller.revents & POLLOUT) { res = ss7_write(ss7, linkset->fd); if (res < 0) { printf("Error in write %s", strerror(errno)); } } #if 1 if (res < 0) m3ua_down_link(ss7, linkset->fd); #endif while ((e = ss7_check_event(ss7))) { if (e) { switch (e->e) { case SS7_EVENT_UP: printf("[%d] --- SS7 Up ---\n", linkset->linkno); //isup_grs(ss7, 1, 24, dpc); c = isup_new_call(ss7); isup_init_call(ss7, c, 1, dpc); isup_grs(ss7, c, 24); break; case MTP2_LINK_UP: printf("[%d] MTP2 link up\n", linkset->linkno); break; case M3UA_LINK_UP: printf("[%d] M3UA link up\n", linkset->linkno); // m3ua_daud(ss7,rl, -1, 1, 2, NULL); // ss7_call(ss7); // m3ua_down_link(ss7, linkset->fd); break; case M3UA_LINK_DOWN: printf("[%d] M3UA link down\n", linkset->linkno); break; case M3UA_ROUTE_REG_RSP: m3ua_rkm_dereg(ss7, rl, rkm, 1); break; case ISUP_EVENT_GRS: printf("Got GRS from cic %d to %d: Acknowledging\n", e->grs.startcic, e->grs.endcic); isup_gra(ss7, e->grs.call, e->grs.endcic, state); break; case ISUP_EVENT_RSC: isup_rlc(ss7, e->rsc.call); break; case ISUP_EVENT_GRA: printf("Got GRA from cic %d to %d.\n", e->gra.startcic, e->gra.endcic); ss7_call(ss7); break; case ISUP_EVENT_BLO: isup_bla(ss7, e->blo.call); break; case ISUP_EVENT_CGB: isup_cgba(ss7, e->cgb.call, e->cgb.endcic, e->cgb.status); break; case ISUP_EVENT_CGU: isup_cgua(ss7, e->cgu.call, e->cgu.endcic, e->cgu.status); break; case ISUP_EVENT_IAM: printf("Got IAM for cic %d and number %s\n", e->iam.cic, e->iam.called_party_num); printf("CallerID is %s\n", e->iam.calling_party_num); printf("Sending ACM\n"); isup_acm(ss7, e->iam.call); printf("Sending ANM\n"); isup_anm(ss7, e->iam.call); break; case ISUP_EVENT_REL: printf("Got REL for cic %d\n", e->rel.cic); isup_rlc(ss7, e->rel.call); //ss7_call(ss7); break; case ISUP_EVENT_ACM: printf("Got ACM for cic %d\n", e->acm.cic); break; case ISUP_EVENT_ANM: printf("Got ANM for cic %d\n", e->anm.cic); isup_rel(ss7, e->anm.call, 16); break; case ISUP_EVENT_RLC: printf("Got RLC for cic %d\n", e->rlc.cic); //ss7_call(ss7); break; default: printf("Unknown event %d\n", e->e); break; } } } } } int dummy(void); int main(int argc, char *argv[]) { struct sockaddr_in addrs[MAX_ADDRESSES]; int ct = 0, sfd; pthread_t t; char *p; struct ss7 *ss7; if (argc < 4) { print_args(); exit(-1); } opc = atoi(argv[2]); dpc = atoi(argv[3]); for (p = strtok(argv[1], ", "); p && ct < MAX_ADDRESSES; p = strtok(NULL, ", ")) { char *q; char hst[128] = {0}; int port = 2905; strncpy(hst, p, -1 + sizeof hst); if ((q = strrchr(hst, ':')) != NULL) { *q++ = 0; port = atoi(q); } addrs[ct].sin_family = AF_INET; addrs[ct].sin_port = htons(port); if (inet_aton(hst, &addrs[ct].sin_addr) != 0) ct++; else fprintf(stderr, "%s: Invalid IP address %.128s, skipped!\n", argv[0], hst); } if (ct <= 0) { fprintf(stderr, "%s: No destinations!\n", argv[0]); print_args(); exit(-1); } #ifdef WITH_SCTP sfd = socket(PF_INET, SOCK_STREAM, IPPROTO_SCTP); if (sfd < 0) { fprintf(stderr, "%s: Socket failed: %s!\n", argv[0], strerror(errno)); exit(-1); } #if 0 if (sctp_connectx(sfd, (void *)addrs, ct, NULL) < 0) { fprintf(stderr, "%s: Connect failed: %s!\n", argv[0], strerror(errno)); exit(-1); } #else if (connect(sfd, (void *)addrs, sizeof addrs[0]) < 0) { fprintf(stderr, "%s: Connect failed: %s!\n", argv[0], strerror(errno)); exit(-1); } #endif #else fprintf(stderr, "%s: No SCTP support. Exiting!\n", argv[0]); exit(-1); #endif ss7 = ss7_new(SS7_ITU); if (!ss7) { perror("ss7_new"); exit(1); } ss7_set_message(myprintf); ss7_set_error(myprintf); ss7_set_network_ind(ss7, SS7_NI_NAT); ss7_set_debug(ss7, 0xfffffff); if ((ss7_add_link(ss7, SS7_TRANSPORT_M3UA, "test", 1, dpc))) { perror("ss7_add_link"); exit(1); } ss7_set_link_fd(ss7, "test", sfd); ss7_set_pc(ss7, opc); ss7_set_call_null((void *)dummy); #if 1 /* Key registration */ { struct routing_label rl = {.type = ss7->switchtype, .dpc = dpc, .opc = opc, .sls = 1}; m3ua_rkm_reg(ss7,rl, &rk, 1); } #endif linkset[0].ss7 = ss7; linkset[0].fd = sfd; linkset[0].linkno = 0; if (pthread_create(&t, NULL, ss7_run, &linkset[0]) != 0) { perror("thread(0)"); exit(1); } /* Wait for it to come up and send data. */ pthread_join(t,NULL); return 0; } int dummy(void) { return 0; } m3ua.diff000644 000766 000000 00000135411 11271756122 013477 0ustar00bagyendawheel000000 000000 Index: isup_masq.c =================================================================== --- isup_masq.c (revision 266) +++ isup_masq.c (working copy) @@ -304,7 +304,7 @@ txbuf[0] = 5; /* ISUP MESSAGE */ txbuf[1] = (link->master->ni << 6) | SIG_ISUP; - rlsize = set_routinglabel(&txbuf[2], rl); + rlsize = mtp3_set_routinglabel(&txbuf[2], rl); memcpy(&txbuf[2 + rlsize], buf, len); Index: parser_debug.c =================================================================== --- parser_debug.c (revision 266) +++ parser_debug.c (working copy) @@ -77,12 +77,12 @@ printf("\n"); - ss7_add_link(ss7, SS7_TRANSPORT_DAHDIDCHAN, 10, -1, 0); + ss7_add_link(ss7, SS7_TRANSPORT_DAHDIDCHAN, "test",10, 0); ss7->debug = SS7_DEBUG_MTP2 | SS7_DEBUG_MTP3 | SS7_DEBUG_ISUP; - ss7->links[0]->state = MTP_INSERVICE; + ss7->mtp2_links[0]->state = MTP_INSERVICE; - mtp2_receive(ss7->links[0], m); + mtp2_receive(ss7->mtp2_links[0]); e = ss7_check_event(ss7); Index: libss7.h =================================================================== --- libss7.h (revision 266) +++ libss7.h (working copy) @@ -70,6 +70,17 @@ #define ISUP_EVENT_RES 33 #define ISUP_EVENT_SAM 34 +/* M3UA events */ +#define M3UA_LINK_UP 35 +#define M3UA_LINK_DOWN 36 +#define M3UA_SEND_FAILED 37 +#define M3UA_DUPU 38 +#define M3UA_ROUTE_REG_RSP 39 +#define M3UA_ROUTE_DEREG_RSP 40 + +/* Generic MTP user message */ +#define MTP_EVENT_UMSG 41 + /* ISUP MSG Flags */ #define ISUP_SENT_GRS (1 << 0) #define ISUP_SENT_CGB (1 << 1) @@ -145,6 +156,7 @@ #define SS7_TRANSPORT_DAHDIDCHAN 0 #define SS7_TRANSPORT_DAHDIMTP2 1 #define SS7_TRANSPORT_TCP 2 +#define SS7_TRANSPORT_M3UA 4 /* What have to do after the hangup */ #define SS7_HANGUP_DO_NOTHING 0 @@ -332,7 +344,7 @@ typedef struct { int e; - int data; + int arg, data; } ss7_event_generic; typedef struct { @@ -376,6 +388,17 @@ struct isup_call *call; } ss7_event_sam; +typedef struct { + int e; + unsigned int opc; + unsigned int dpc; + unsigned char sls; + + unsigned char userpart; + unsigned int len; + unsigned char data[1024]; +} ss7_event_upartmsg; + typedef union { int e; ss7_event_generic gen; @@ -407,6 +430,7 @@ ss7_event_cic lpa; ss7_event_susres susres; ss7_event_sam sam; + ss7_event_upartmsg umsg; } ss7_event; void ss7_set_message(void (*func)(struct ss7 *ss7, char *message)); Index: ss7.c =================================================================== --- ss7.c (revision 266) +++ ss7.c (working copy) @@ -39,11 +39,12 @@ #include #include "libss7.h" #include "ss7_internal.h" + #include "mtp2.h" #include "isup.h" #include "mtp3.h" +#include "m3ua.h" - static void (*__ss7_message)(struct ss7 *ss7, char *message); static void (*__ss7_error)(struct ss7 *ss7, char *message); @@ -142,17 +143,63 @@ return calloc(1, sizeof(struct ss7_msg)); } -unsigned char * ss7_msg_userpart(struct ss7_msg *msg) +int ss7_rl_to_route(struct ss7 *ss7, struct routing_label rl, int userpart, struct ss7_route *rt) { - return msg->buf + MTP2_SIZE + SIO_SIZE; + rt->sls = rl.sls; /* Copy sls value over */ + if (mtp3_rl_to_link(ss7, rl, userpart, rt) < 0) + return m3ua_rl_to_link(ss7, rl, userpart, 1, rt); + return 0; } -void ss7_msg_userpart_len(struct ss7_msg *msg, int len) +int ss7_rl_to_route_no_sls(struct ss7 *ss7, struct routing_label rl, int userpart, struct ss7_route *rt) { - msg->size = MTP2_SIZE + SIO_SIZE + len; - return; + rt->sls = rl.sls = 1; /* Give it any odd value. Most useful for non-ISUP and M3UA */ + if (mtp3_rl_to_link(ss7, rl, userpart, rt) < 0) + return m3ua_rl_to_link(ss7, rl, userpart, 0, rt); + return 0; } +unsigned char *ss7_msg_userpart(int route_type, struct ss7_msg *msg) +{ + if (route_type == MTP3_ROUTE) + return msg->buf + MTP2_SIZE + SIO_SIZE; + else if (route_type == M3UA_ROUTE) + return msg->buf + M3UA_DATA_HLEN + M3UA_COMMON_HLEN; + else + return msg->buf; +} + +void ss7_msg_userpart_len(int route_type, struct ss7_msg *msg, int len) +{ + if (route_type == MTP3_ROUTE) + msg->size = MTP2_SIZE + SIO_SIZE + len; + else if (route_type == M3UA_ROUTE) + msg->size = M3UA_DATA_HLEN + len; + else + msg->size = len; +} + +int ss7_transmit(struct ss7 *ss7, int userpart, struct ss7_route rt, int prio, struct ss7_msg *m) +{ + if (rt.type == MTP3_ROUTE) + return mtp3_transmit(ss7, rt, userpart, prio, m); + else if (rt.type == M3UA_ROUTE) + return m3ua_transmit(ss7, rt, userpart, prio, m); + else { + ss7_error(ss7, "No signalling route/link available sending message!\n"); + free(m); + return -1; + } +} +int ss7_set_routinglabel(unsigned char *sif, int route_type, struct routing_label *rl) +{ + if (route_type == MTP3_ROUTE) + return mtp3_set_routinglabel(sif, rl); + else if (route_type == M3UA_ROUTE) + return m3ua_set_routinglabel(sif, rl); + return 0; +} + ss7_event * ss7_next_empty_event(struct ss7 *ss7) { ss7_event *e; @@ -186,6 +233,7 @@ int ss7_start(struct ss7 *ss7) { mtp3_start(ss7); + m3ua_start(ss7); return 0; } @@ -211,9 +259,16 @@ { int i; - for (i = 0; i < ss7->numlinks; i++) { - if (!strcasecmp(ss7->links[i]->name, name)) { - ss7->links[i]->fd = fd; + for (i = 0; i < ss7->num_m3ua_links; i++) { + if (!strcasecmp(ss7->m3ua_links[i]->name, name)) { + ss7->m3ua_links[i]->fd = fd; + return m3ua_set_sockopts(fd); + } + } + + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (!strcasecmp(ss7->mtp2_links[i]->name, name)) { + ss7->mtp2_links[i]->fd = fd; break; } } @@ -225,7 +280,7 @@ { struct mtp2 *m; - if (ss7->numlinks >= SS7_MAX_LINKS) + if (ss7->num_mtp2_links >= SS7_MAX_LINKS) return NULL; m = mtp2_new(name, ss7->switchtype); @@ -265,51 +320,67 @@ int ss7_add_link(struct ss7 *ss7, int transport, char *name, int slc, unsigned int adjpc) { - struct mtp2 *m; - if (ss7->numlinks >= SS7_MAX_LINKS) - return -1; + if (transport == SS7_TRANSPORT_M3UA) { + struct m3ua *m; - if (!name && (name[0] == 0)) - return -1; - - m = mtp2_new(name, ss7->switchtype); - - if (!m) - return -1; - - m->master = ss7; - - if ((transport == SS7_TRANSPORT_DAHDIDCHAN) || (transport == SS7_TRANSPORT_DAHDIMTP2) || - (transport == SS7_TRANSPORT_TCP)) { - + if (ss7->num_m3ua_links >= SS7_MAX_LINKS) + return -1; + m = m3ua_new(name, adjpc); + if (!m) + return -1; if (slc > -1) m->slc = slc; - else - m->slc = ss7->numlinks; + else + m->slc = ss7->num_m3ua_links; + m->master = ss7; + ss7->m3ua_links[ss7->num_m3ua_links++] = m; + + } else { + struct mtp2 *m; + if (ss7->num_mtp2_links >= SS7_MAX_LINKS) + return -1; - ss7->numlinks += 1; - - if (transport == SS7_TRANSPORT_DAHDIMTP2) - m->flags |= MTP2_FLAG_ZAPMTP2; - - if (transport == SS7_TRANSPORT_TCP) - m->flags |= MTP2_FLAG_TCP; - - ss7->links[ss7->numlinks - 1] = m; - - ss7_set_adjpc(ss7->links[ss7->numlinks-1], adjpc); - - if (transport == SS7_TRANSPORT_TCP) { - ss7->links[ss7->numlinks - 1]->adj_sp->state = MTP3_UP; - ss7->mtp2_linkstate[ss7->numlinks - 1] = MTP2_LINKSTATE_UP; - ss7->links[ss7->numlinks - 1]->tcpreadstate = TCPSTATE_NEED_LEN; + if (!name && (name[0] == 0)) + return -1; + + m = mtp2_new(name, ss7->switchtype); + + if (!m) + return -1; + + m->master = ss7; + + if ((transport == SS7_TRANSPORT_DAHDIDCHAN) || (transport == SS7_TRANSPORT_DAHDIMTP2) || + (transport == SS7_TRANSPORT_TCP)) { + + if (slc > -1) + m->slc = slc; + else + m->slc = ss7->num_mtp2_links; + + ss7->num_mtp2_links += 1; + + if (transport == SS7_TRANSPORT_DAHDIMTP2) + m->flags |= MTP2_FLAG_ZAPMTP2; + + if (transport == SS7_TRANSPORT_TCP) + m->flags |= MTP2_FLAG_TCP; + + ss7->mtp2_links[ss7->num_mtp2_links - 1] = m; + + ss7_set_adjpc(ss7->mtp2_links[ss7->num_mtp2_links-1], adjpc); + + if (transport == SS7_TRANSPORT_TCP) { + ss7->mtp2_links[ss7->num_mtp2_links - 1]->adj_sp->state = MTP3_UP; + ss7->mtp2_linkstate[ss7->num_mtp2_links - 1] = MTP2_LINKSTATE_UP; + ss7->mtp2_links[ss7->num_mtp2_links - 1]->tcpreadstate = TCPSTATE_NEED_LEN; + } + + } else { + return -1; } - - } else { - return -1; } - return 0; } @@ -319,20 +390,26 @@ struct mtp2 *winner = NULL; int flags = POLLPRI | POLLIN; - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->fd == fd) { - winner = ss7->links[i]; + for (i = 0; i < ss7->num_mtp2_links; i++) + if (ss7->mtp2_links[i]->fd == fd) { + winner = ss7->mtp2_links[i]; break; } - } + /* Maybe it's a lite link */ - for (i = 0; i < ss7->numslavelinks; i++) { - if (ss7->slavelinks[i]->fd == fd) { - winner = ss7->links[i]; - break; - } - } + if (!winner) + for (i = 0; i < ss7->numslavelinks; i++) + if (ss7->slavelinks[i]->fd == fd) { + winner = ss7->mtp2_links[i]; + break; + } + + /* not needed */ + if (!winner) + for (i = 0; i < ss7->num_m3ua_links; i++) + if (ss7->m3ua_links[i]->fd == fd) + return flags; if (!winner) return -1; @@ -434,15 +511,15 @@ isup_free_all_calls(ss7); /* MTP3 */ - for (i = 0; i > ss7->numsps; i++) { - mtp3_destroy_all_routes(ss7->adj_sps[i]); - free(ss7->adj_sps[i]); + for (i = 0; i > ss7->num_mtp2_sps; i++) { + mtp3_destroy_all_routes(ss7->adj_mtp2_sps[i]); + free(ss7->adj_mtp2_sps[i]); } - for (i = 0; i > ss7->numlinks; i++) { - flush_bufs(ss7->links[i]); - mtp3_free_co(ss7->links[i]); - free(ss7->links[i]); + for (i = 0; i > ss7->num_mtp2_links; i++) { + flush_bufs(ss7->mtp2_links[i]); + mtp3_free_co(ss7->mtp2_links[i]); + free(ss7->mtp2_links[i]); } free(ss7); @@ -474,8 +551,8 @@ { int res, i, winner = -1; - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->fd == fd) { + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i]->fd == fd) { winner = i; break; } @@ -484,7 +561,7 @@ if (winner < 0) return -1; - res = mtp2_transmit(ss7->links[winner]); + res = mtp2_transmit(ss7->mtp2_links[winner]); return res; } @@ -495,23 +572,30 @@ int winner = -1; int i; - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->fd == fd) { + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i]->fd == fd) { winner = i; break; } } if (winner != -1) { - if (ss7->links[winner]->flags & MTP2_FLAG_TCP) { - res = isup_ip_receive(ss7->links[winner]); + if (ss7->mtp2_links[winner]->flags & MTP2_FLAG_TCP) { + res = isup_ip_receive(ss7->mtp2_links[winner]); goto exit; } else { - res = mtp2_receive(ss7->links[winner]); + res = mtp2_receive(ss7->mtp2_links[winner]); goto exit; } - } + } else /* Check m3ua links */ + for (i = 0; i < ss7->num_m3ua_links; i++) { + if (ss7->m3ua_links[i]->fd == fd) { + res = m3ua_receive(ss7->m3ua_links[i]); + goto exit; + } + } + /* Maybe it's a lite link */ @@ -532,6 +616,21 @@ return res; } +int ss7_userpart_receive(struct ss7 *ss7, struct routing_label rl, unsigned char userpart, void *data, int data_len) +{ + ss7_event *e = ss7_next_empty_event(ss7); + if (e) { + e->e = MTP_EVENT_UMSG; + e->umsg.opc = rl.opc; + e->umsg.dpc = rl.dpc; + e->umsg.sls = rl.sls; + e->umsg.userpart = userpart; + e->umsg.len = data_len; + memcpy(e->umsg.data, data, e->umsg.len); + return 0; + } return -1; +} + static inline char * changeover2str(int state) { switch(state) { @@ -576,14 +675,14 @@ { int mtp2state, i; - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i] == link) { + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i] == link) { mtp2state = ss7->mtp2_linkstate[i]; break; } } - if (i == ss7->numlinks) + if (i == ss7->num_mtp2_links) return "UNKNOWN"; @@ -659,12 +758,12 @@ cust_printf(fd, "Switch type: %s\n", (ss7->switchtype == SS7_ITU) ? "ITU" : "ANSI"); cust_printf(fd, "Our point code: %s\n", pc_str); cust_printf(fd, "SLS shift: %i\n", ss7->sls_shift); - cust_printf(fd, "numlinks: %i\n", ss7->numlinks); - cust_printf(fd, "numsps: %i\n", ss7->numsps); + cust_printf(fd, "numlinks: %i\n", ss7->num_mtp2_links); + cust_printf(fd, "numsps: %i\n", ss7->num_mtp2_sps); - for (j = 0; j < ss7->numsps; j++) { - adj_sp = ss7->adj_sps[j]; + for (j = 0; j < ss7->num_mtp2_sps; j++) { + adj_sp = ss7->adj_mtp2_sps[j]; ss7_pc_to_str(ss7->switchtype, adj_sp->adjpc, pc_str); cust_printf(fd, " ---------------------------------\n Adjacent SP PC: %s STATE: %s\n", pc_str, mtp3_state(adj_sp->state)); cust_printf(fd, " TRA: %s%s T19: %s T21: %s\n", (adj_sp->tra & GOT) ? "GOT " : "", (adj_sp->tra & SENT) ? "SENT" : "", @@ -687,8 +786,8 @@ if (link->mtp3_timer[x] > -1) { strcpy(p, mtp3_timer2str(x)); p += strlen(p); - sprintf(p, "(%lis)%c", ss7->ss7_sched[ss7->links[i]->mtp3_timer[x]].when.tv_sec - time(NULL), - ss7->ss7_sched[ss7->links[i]->mtp3_timer[x]].callback ? ' ' : '!'); + sprintf(p, "(%lis)%c", ss7->ss7_sched[ss7->mtp2_links[i]->mtp3_timer[x]].when.tv_sec - time(NULL), + ss7->ss7_sched[ss7->mtp2_links[i]->mtp3_timer[x]].callback ? ' ' : '!'); p += strlen(p); } } @@ -699,7 +798,7 @@ cust_printf(fd, " STD Test: %s\n", link->std_test_passed ? "passed" : "failed"); cust_printf(fd, " Got, sent :%s\n", got_sent2str(got_sent_buf, link->got_sent_netmsg)); cust_printf(fd, " Inhibit: %s%s\n", (link->inhibit & INHIBITED_LOCALLY) ? "Locally " : " ", - (ss7->links[i]->inhibit & INHIBITED_REMOTELY) ? "Remotely" : ""); + (ss7->mtp2_links[i]->inhibit & INHIBITED_REMOTELY) ? "Remotely" : ""); cust_printf(fd, " Changeover: %s\n", changeover2str(link->changeover)); cust_printf(fd, " Tx buffer: %i\n", len_buf(link->tx_buf)); cust_printf(fd, " Tx queue: %i\n", len_buf(link->tx_q)); Index: ss7_internal.h =================================================================== --- ss7_internal.h (revision 266) +++ ss7_internal.h (working copy) @@ -76,6 +76,16 @@ unsigned char sls; }; +/* Route for a message, based on routing label: We need this because message format depends on sender module. */ +struct ss7_route { + unsigned char type; /* Route provider: MTP3 or M3UA */ + unsigned char sls; /* Signalling link selection */ + void *link; /* Pointer to module-specific link */ + void *data; /* Route specific data */ +}; +#define MTP3_ROUTE 1 +#define M3UA_ROUTE 2 + struct ss7_msg { unsigned char buf[512]; unsigned int size; @@ -106,8 +116,8 @@ struct ss7 { unsigned int switchtype; - unsigned int numsps; - unsigned int numlinks; + unsigned int num_mtp2_sps; + unsigned int num_mtp2_links; /* Our point code */ point_code pc; @@ -127,8 +137,9 @@ struct isup_call *calls; unsigned int mtp2_linkstate[SS7_MAX_LINKS]; - struct mtp2 *links[SS7_MAX_LINKS]; - struct adjacent_sp *adj_sps[SS7_MAX_ADJSPS]; + struct mtp2 *mtp2_links[SS7_MAX_LINKS]; + struct adjacent_sp *adj_mtp2_sps[SS7_MAX_ADJSPS]; + int isup_timers[ISUP_MAX_TIMERS]; int mtp3_timers[MTP3_MAX_TIMERS]; unsigned char sls_shift; @@ -136,12 +147,17 @@ unsigned char cb_seq; int linkset_up_timer; + /* Data members for M3UA */ + struct m3ua *m3ua_links[SS7_MAX_LINKS]; + unsigned int num_m3ua_links; + /* lite links are links that pretty much go straight to and from a user part */ struct mtp2 *slavelinks[SS7_MAX_LINKS]; int numslavelinks; /* Data members needed for ISUP slave channels */ struct isup_masq isup_masq_table; + }; /* Getto hacks for developmental purposes */ @@ -156,18 +172,27 @@ void ss7_schedule_del(struct ss7 *ss7,int *id); -unsigned char *ss7_msg_userpart(struct ss7_msg *m); +unsigned char *ss7_msg_userpart(int routing_type, struct ss7_msg *m); -void ss7_msg_userpart_len(struct ss7_msg *m, int len); +void ss7_msg_userpart_len(int routing_type, struct ss7_msg *m, int len); void ss7_message(struct ss7 *ss7, char *fmt, ...); void ss7_error(struct ss7 *ss7, char *fmt, ...); +int ss7_userpart_receive(struct ss7 *ss7, struct routing_label rl, unsigned char userpart, void *data, int data_len); + void ss7_dump_buf(struct ss7 *ss7, int tabs, unsigned char *buf, int len); void ss7_dump_msg(struct ss7 *ss7, unsigned char *buf, int len); +int ss7_rl_to_route(struct ss7 *ss7, struct routing_label rl, int userpart, struct ss7_route *rt); +int ss7_rl_to_route_no_sls(struct ss7 *ss7, struct routing_label rl, int userpart, struct ss7_route *rt); + +int ss7_set_routinglabel(unsigned char *sif, int route_type, struct routing_label *rl); + +int ss7_transmit(struct ss7 *, int userpart, struct ss7_route rt, int prio, struct ss7_msg *m); + void (*ss7_notinservice)(struct ss7 *ss7, int cic, unsigned int dpc); int (*ss7_hangup)(struct ss7 *ss7, int cic, unsigned int dpc, int cause, int do_hangup); Index: isup.c =================================================================== --- isup.c (revision 266) +++ isup.c (working copy) @@ -396,7 +396,7 @@ static FUNC_DUMP(nature_of_connection_ind_dump) { unsigned char con = parm[0]; - char *continuity; + char *continuity = ""; /* because gcc -O4 -Wall complains */ ss7_message(ss7, "\t\t\tSatellites in connection: %d\n", con&0x03); con>>=2; @@ -442,7 +442,7 @@ static FUNC_DUMP(forward_call_ind_dump) { - char *cb_str, *hg_str, *kj_str; + char *cb_str="", *hg_str="", *kj_str=""; /* So gcc -O4 -Wall doesn't complain */ switch ((parm[0] >> 1) & 3) { case 0: cb_str = "no end-to-end"; @@ -1897,7 +1897,7 @@ static FUNC_DUMP(circuit_state_ind_dump) { unsigned char dcbits, babits, febits; - char *ba_str, *dc_str, *fe_str; + char *ba_str="", *dc_str="", *fe_str=""; int i; for (i = 0; i < len; i++) { @@ -2868,10 +2868,11 @@ unsigned char *rlptr; int ourmessage = -1; int rlsize; - unsigned char *varoffsets = NULL, *opt_ptr; + unsigned char *varoffsets = NULL, *opt_ptr=NULL; int fixedparams = 0, varparams = 0, optparams = 0; int len = sizeof(struct ss7_msg); struct routing_label rl; + struct ss7_route rt = {.type = 0}; int res = 0; int offset = 0; int x = 0; @@ -2886,15 +2887,17 @@ return -1; } - rlptr = ss7_msg_userpart(msg); - rl.opc = ss7->pc; /* use CIC's DPC instead of linkset's DPC */ rl.dpc = c->dpc; rl.sls = c->sls; rl.type = ss7->switchtype; - rlsize = set_routinglabel(rlptr, &rl); + + ss7_rl_to_route(ss7, rl, SIG_ISUP, &rt); /* Ignore errors here, until send below. */ + + rlptr = ss7_msg_userpart(rt.type, msg); + rlsize = ss7_set_routinglabel(rlptr, rt.type, &rl); mh = (struct isup_h *)(rlptr + rlsize); /* Note to self, do NOT put a typecasted pointer next to an addition operation */ /* Set the CIC - ITU style */ @@ -3003,9 +3006,9 @@ } - ss7_msg_userpart_len(msg, offset + rlsize + CIC_SIZE + 1); /* Message type length is 1 */ + ss7_msg_userpart_len(rt.type, msg, offset + rlsize + CIC_SIZE + 1); /* Message type length is 1 */ - return mtp3_transmit(ss7, SIG_ISUP, rl, priority, msg); + return ss7_transmit(ss7, SIG_ISUP, rt, priority, msg); } int isup_dump(struct ss7 *ss7, struct mtp2 *link, unsigned char *buf, int len) @@ -3166,7 +3169,7 @@ return 0; } -int isup_receive(struct ss7 *ss7, struct mtp2 *link, struct routing_label *rl, unsigned char *buf, int len) +int isup_receive(struct ss7 *ss7, struct routing_label *rl, unsigned char *buf, int len) { unsigned short cic; struct isup_h *mh; Index: mtp3.c =================================================================== --- mtp3.c (revision 266) +++ mtp3.c (working copy) @@ -48,7 +48,7 @@ #define rl_size(ss7) (((ss7)->switchtype == SS7_ITU) ? 4 : 7) static struct mtp2 * slc_to_mtp2(struct ss7 *ss7, unsigned int slc); - +static inline int mtp3_transmit_int(struct ss7 *ss7, unsigned char userpart, struct routing_label rl, int priority, struct ss7_msg *m); static char * userpart2str(unsigned char userpart) { switch (userpart) { @@ -126,7 +126,7 @@ return (sio >> 4) & 0x3; } -int set_routinglabel(unsigned char *sif, struct routing_label *rl) +int mtp3_set_routinglabel(unsigned char *sif, struct routing_label *rl) { unsigned char *buf = sif; switch (rl->type) { @@ -178,12 +178,12 @@ static inline int link_available(struct ss7 *ss7, int linkid, struct ss7_msg ***buffer, struct routing_label rl) { if ((ss7->mtp2_linkstate[linkid] == MTP2_LINKSTATE_UP && - ss7->links[linkid]->adj_sp->state == MTP3_UP && - ss7->links[linkid]->changeover != CHANGEOVER_COMPLETED) || - (ss7->links[linkid]->changeover == CHANGEOVER_IN_PROGRESS) || - ss7->links[linkid]->changeover == CHANGEBACK_INITIATED) { + ss7->mtp2_links[linkid]->adj_sp->state == MTP3_UP && + ss7->mtp2_links[linkid]->changeover != CHANGEOVER_COMPLETED) || + (ss7->mtp2_links[linkid]->changeover == CHANGEOVER_IN_PROGRESS) || + ss7->mtp2_links[linkid]->changeover == CHANGEBACK_INITIATED) { - struct mtp3_route *route = ss7->links[linkid]->adj_sp->routes; + struct mtp3_route *route = ss7->mtp2_links[linkid]->adj_sp->routes; while (route) { if (route->dpc == rl.dpc) { if (route->t6 > -1) { @@ -201,49 +201,85 @@ route = route->next; } - switch (ss7->links[linkid]->changeover) { + switch (ss7->mtp2_links[linkid]->changeover) { case CHANGEOVER_IN_PROGRESS: case CHANGEOVER_INITIATED: - *buffer = &ss7->links[linkid]->co_buf; + *buffer = &ss7->mtp2_links[linkid]->co_buf; return 1; case CHANGEBACK_INITIATED: case CHANGEBACK: - *buffer = &ss7->links[linkid]->cb_buf; + *buffer = &ss7->mtp2_links[linkid]->cb_buf; return 1; default: *buffer = NULL; return 1; } - } else { + } else *buffer = NULL; - return 0; - } + + return 0; } + static inline struct mtp2 * rl_to_link(struct ss7 *ss7, struct routing_label rl, struct ss7_msg ***buffer) { int linkid; - linkid = (rl.sls >> ss7->sls_shift) % ss7->numlinks; + linkid = (rl.sls >> ss7->sls_shift) % ss7->num_mtp2_links; if (link_available(ss7, linkid, buffer, rl)) - return ss7->links[linkid]; + return ss7->mtp2_links[linkid]; else { struct mtp2 *winner = NULL; int i; - for (i = 0; i < ss7->numlinks; i++) { + for (i = 0; i < ss7->num_mtp2_links; i++) { if (link_available(ss7, i, buffer, rl)) { - winner = ss7->links[i]; + winner = ss7->mtp2_links[i]; break; } } return winner; } + } +static struct mtp2 * rl_to_mtp2_nomtp3check(struct ss7 *ss7, struct routing_label rl) +{ + int i = 0; + struct mtp2 *link = NULL; + + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i]->slc == rl.sls && (ss7->mtp2_links[i]->adj_sp->adjpc == rl.dpc)) { + link = ss7->mtp2_links[i]; + break; + } + } + + return link; +} + +int mtp3_rl_to_link(struct ss7 *ss7, struct routing_label rl, int userpart, struct ss7_route *rt) +{ + struct ss7_msg **buf = NULL; + + if (ss7->num_mtp2_links == 0) + return -1; + else if (userpart == SIG_ISUP || userpart == SIG_SCCP) + rt->link = rl_to_link(ss7, rl, &buf); + else + rt->link = rl_to_mtp2_nomtp3check(ss7, rl); + if (rt->link == NULL) + return -1; + + rt->type = MTP3_ROUTE; + rt->data = buf; + + return 0; +} + struct net_mng_message net_mng_messages[] = { { 1, 1, "COO"}, { 1, 2, "COA"}, @@ -284,8 +320,8 @@ { int i; - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i] == link) + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i] == link) ss7->mtp2_linkstate[i] = newstate; } } @@ -336,13 +372,13 @@ return; } - layer4 = ss7_msg_userpart(m); + layer4 = ss7_msg_userpart(MTP3_ROUTE, m); rl.type = ss7->switchtype; rl.opc = ss7->pc; rl.dpc = link->adj_sp->adjpc; rl.sls = link->slc; - rllen = set_routinglabel(layer4, &rl); + rllen = mtp3_set_routinglabel(layer4, &rl); layer4 += rllen; set_h0(layer4, 1); @@ -350,9 +386,9 @@ layer4[1] = (testlen << 4); memcpy(&layer4[2], testmessage, testlen); - ss7_msg_userpart_len(m, rllen + testlen + 2); + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + testlen + 2); - if (mtp3_transmit(link->master, (ss7->switchtype == SS7_ITU) ? SIG_STD_TEST : SIG_SPEC_TEST, rl, 3, m) > -1 && + if (mtp3_transmit_int(link->master, (ss7->switchtype == SS7_ITU) ? SIG_STD_TEST : SIG_SPEC_TEST, rl, 3, m) > -1 && link->master->mtp3_timers[MTP3_TIMER_Q707_T1] > 0) { if (link->mtp3_timer[MTP3_TIMER_Q707_T1] > -1) ss7_schedule_del(ss7, &link->mtp3_timer[MTP3_TIMER_Q707_T1]); @@ -400,15 +436,15 @@ int res = 0, i; struct mtp3_route *route; - for (i = 0; i < ss7->numlinks; i++) - if (ss7->links[i]->std_test_passed && - ((ignore_inhibit && ss7->links[i]->inhibit) ? 1 : - (ss7->links[i]->changeover == NO_CHANGEOVER || ss7->links[i]->changeover == CHANGEBACK))) { + for (i = 0; i < ss7->num_mtp2_links; i++) + if (ss7->mtp2_links[i]->std_test_passed && + ((ignore_inhibit && ss7->mtp2_links[i]->inhibit) ? 1 : + (ss7->mtp2_links[i]->changeover == NO_CHANGEOVER || ss7->mtp2_links[i]->changeover == CHANGEBACK))) { if (dpc == -1) res++; else { - route = ss7->links[i]->adj_sp->routes; + route = ss7->mtp2_links[i]->adj_sp->routes; while (route) { if (route->dpc == dpc ) { if (route->state == TFA || route->state == TFR_NON_ACTIVE) @@ -428,8 +464,8 @@ int i, j, mtp3_up = 0; int av_links = available_links(ss7, -1, 0); - for (i = 0; i < ss7->numsps; i++) { - if (ss7->adj_sps[i]->state == MTP3_UP) { + for (i = 0; i < ss7->num_mtp2_sps; i++) { + if (ss7->adj_mtp2_sps[i]->state == MTP3_UP) { mtp3_up = 1; break; } @@ -437,27 +473,27 @@ if (!av_links && mtp3_up) { /* find a locally inhibited link */ - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->inhibit & INHIBITED_LOCALLY) { - if (!(ss7->links[i]->got_sent_netmsg & SENT_LUN)) { - AUTORL(rl, ss7->links[i]); - net_mng_send(ss7->links[i], NET_MNG_LUN, rl, 0); - ss7_message(ss7, "Uninhibiting locally inhibited link (no more signalling links are in service) SLC: %i ADJPC: %i\n", ss7->links[i]->slc, ss7->links[i]->dpc); + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i]->inhibit & INHIBITED_LOCALLY) { + if (!(ss7->mtp2_links[i]->got_sent_netmsg & SENT_LUN)) { + AUTORL(rl, ss7->mtp2_links[i]); + net_mng_send(ss7->mtp2_links[i], NET_MNG_LUN, rl, 0); + ss7_message(ss7, "Uninhibiting locally inhibited link (no more signalling links are in service) SLC: %i ADJPC: %i\n", ss7->mtp2_links[i]->slc, ss7->mtp2_links[i]->dpc); } - if (ss7->links[i]->inhibit & INHIBITED_REMOTELY) - i = ss7->numlinks; /* in this case force remote uninhibit too ! */ + if (ss7->mtp2_links[i]->inhibit & INHIBITED_REMOTELY) + i = ss7->num_mtp2_links; /* in this case force remote uninhibit too ! */ break; } } /* try force uninhibit */ - if (i == ss7->numlinks) { - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->inhibit & INHIBITED_REMOTELY) { - if (!(ss7->links[i]->got_sent_netmsg & SENT_LFU)) + if (i == ss7->num_mtp2_links) { + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i]->inhibit & INHIBITED_REMOTELY) { + if (!(ss7->mtp2_links[i]->got_sent_netmsg & SENT_LFU)) break; - AUTORL(rl, ss7->links[i]); - net_mng_send(ss7->links[i], NET_MNG_LFU, rl, 0); - ss7_message(ss7, "Forced uninhibiting remotely inhibited link (no more signalling links are in service) SLC: %i ADJPC: %i\n", ss7->links[i]->slc, ss7->links[i]->dpc); + AUTORL(rl, ss7->mtp2_links[i]); + net_mng_send(ss7->mtp2_links[i], NET_MNG_LFU, rl, 0); + ss7_message(ss7, "Forced uninhibiting remotely inhibited link (no more signalling links are in service) SLC: %i ADJPC: %i\n", ss7->mtp2_links[i]->slc, ss7->mtp2_links[i]->dpc); break; } } @@ -476,9 +512,9 @@ ss7_linkset_up_event(ss7); /* Set links to changeover state which are not came up yet */ - for (i = 0; i < ss7->numlinks; i++) - if (!ss7->links[i]->std_test_passed) - ss7->links[i]->changeover = CHANGEOVER_COMPLETED; + for (i = 0; i < ss7->num_mtp2_links; i++) + if (!ss7->mtp2_links[i]->std_test_passed) + ss7->mtp2_links[i]->changeover = CHANGEOVER_COMPLETED; } if (ss7->state != SS7_STATE_DOWN && !mtp3_up) { @@ -493,8 +529,8 @@ e->e = SS7_EVENT_DOWN; isup_free_all_calls(ss7); struct mtp2 *link; - for (i = 0; i < ss7->numlinks; i++) { - link = ss7->links[i]; + for (i = 0; i < ss7->num_mtp2_links; i++) { + link = ss7->mtp2_links[i]; if (link->inhibit & INHIBITED_LOCALLY) link->changeover = CHANGEOVER_COMPLETED; /* because will be stopped all of the timers and flushed the buffers */ else @@ -614,7 +650,7 @@ userpart = get_userpart(cur->buf[MTP2_SIZE]); priority = get_priority(cur->buf[MTP2_SIZE]); get_routinglabel(ss7->switchtype, cur->buf + MTP2_SIZE + 1, &rl); - mtp3_transmit(ss7, userpart, rl, priority, cur); + mtp3_transmit_int(ss7, userpart, rl, priority, cur); cur = next; } *buf = NULL; @@ -1391,11 +1427,11 @@ return -1; } - layer4 = ss7_msg_userpart(m); + layer4 = ss7_msg_userpart(MTP3_ROUTE, m); rl.type = ss7->switchtype; rl.opc = ss7->pc; - rllen = set_routinglabel(layer4, &rl); + rllen = mtp3_set_routinglabel(layer4, &rl); layer4 += rllen; *layer4 = h0h1; layer4++; @@ -1411,12 +1447,12 @@ } link->cb_seq = (unsigned char) param; /* save the CBD sequence, we may need on retransmit */ *layer4 = (unsigned char) param; /* CB code */ - ss7_msg_userpart_len(m, rllen + 1 + 1); /* rl + CB code */ + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1 + 1); /* rl + CB code */ break; case NET_MNG_CBA: can_reroute = 2; *layer4 = (unsigned char) param; /* CB code */ - ss7_msg_userpart_len(m, rllen + 1 + 1); /* rl + CB code */ + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1 + 1); /* rl + CB code */ break; case NET_MNG_COO: can_reroute = 1; @@ -1428,16 +1464,16 @@ ss7_message(ss7, "MTP3 T2 timer started on link SLC: %i ADJPC: %i\n", link->slc, link->dpc); } *layer4 = (unsigned char) param; /* FSN of last accepted MSU */ - ss7_msg_userpart_len(m, rllen + 1 + 1); /* rl + FSN of last accepted MSU */ + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1 + 1); /* rl + FSN of last accepted MSU */ break; case NET_MNG_COA: can_reroute = 2; *layer4 = (unsigned char) param; /* FSN of last accepted MSU */ - ss7_msg_userpart_len(m, rllen + 1 + 1); /* rl + FSN of last accepted MSU */ + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1 + 1); /* rl + FSN of last accepted MSU */ break; case NET_MNG_LUN: link->got_sent_netmsg |= SENT_LUN; - ss7_msg_userpart_len(m, rllen + 1); /* no more params */ + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1); /* no more params */ if (ss7->mtp3_timers[MTP3_TIMER_T14] > 0) { ss7_message(ss7, "MTP3 T12 timer started on link SLC: %i ADJPC: %i\n", link->slc, link->dpc); if (link->mtp3_timer[MTP3_TIMER_T12] == -1) @@ -1450,7 +1486,7 @@ break; case NET_MNG_LIN: link->got_sent_netmsg |= SENT_LIN; - ss7_msg_userpart_len(m, rllen + 1); /* no more params */ + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1); /* no more params */ if (ss7->mtp3_timers[MTP3_TIMER_T14] > 0) { ss7_message(ss7, "MTP3 T14 timer started on link SLC: %i ADJPC: %i\n", link->slc, link->dpc); if (link->mtp3_timer[MTP3_TIMER_T14] == -1) @@ -1469,7 +1505,7 @@ } link->adj_sp->tra |= SENT; - ss7_msg_userpart_len(m, rllen + 1); /* no more params */ + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1); /* no more params */ break; case NET_MNG_ECO: can_reroute = 1; @@ -1480,11 +1516,11 @@ link->mtp3_timer[MTP3_TIMER_T2] = ss7_schedule_event(ss7, ss7->mtp3_timers[MTP3_TIMER_T2], &mtp3_t2_expired, link); ss7_message(ss7, "MTP3 T2 timer started on link SLC: %i ADJPC: %i\n", link->slc, link->dpc); } - ss7_msg_userpart_len(m, rllen + 1); /* no more params */ + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1); /* no more params */ break; case NET_MNG_ECA: can_reroute = 2; - ss7_msg_userpart_len(m, rllen + 1); /* no more params */ + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1); /* no more params */ break; case NET_MNG_LFU: link->got_sent_netmsg |= SENT_LFU; @@ -1502,7 +1538,7 @@ case NET_MNG_LID: case NET_MNG_LLT: case NET_MNG_LRT: - ss7_msg_userpart_len(m, rllen + 1); /* no more params */ + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1); /* no more params */ break; case NET_MNG_TFP: case NET_MNG_TFA: @@ -1512,7 +1548,7 @@ /* TODO: ANSI!!!! */ layer4[0] = (unsigned char) (param & 0xff); layer4[1] = (unsigned char) ((param >> 8) & 0xff); - ss7_msg_userpart_len(m, rllen + 1 + 2); + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + 1 + 2); break; default: ss7_error(link->master, "Invalid or unimplemented NET MSG!\n"); @@ -1527,37 +1563,37 @@ ss7_error(ss7, "The adjacent SP %i sent COO, ECO on the same link: %i, we answer on another!!\n", rl.dpc, rl.sls); else { rl.sls = link->slc; - return mtp3_transmit(ss7, SIG_NET_MNG, rl, 3, m); + return mtp3_transmit_int(ss7, SIG_NET_MNG, rl, 3, m); } } - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->std_test_passed && ss7->links[i] != link) { - rl.sls = ss7->links[i]->slc; - return mtp3_transmit(ss7, SIG_NET_MNG, rl, 3,m); + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i]->std_test_passed && ss7->mtp2_links[i] != link) { + rl.sls = ss7->mtp2_links[i]->slc; + return mtp3_transmit_int(ss7, SIG_NET_MNG, rl, 3,m); } } } else if (can_reroute == 1) { /* 1st try to send COO, CBD, ECO via another link */ - for (i = 0; i < ss7->numlinks; i++) - if (ss7->links[i]->std_test_passed && ss7->links[i] != link) { - rl.sls = ss7->links[i]->slc; - return mtp3_transmit(ss7, SIG_NET_MNG, rl, 3, m); + for (i = 0; i < ss7->num_mtp2_links; i++) + if (ss7->mtp2_links[i]->std_test_passed && ss7->mtp2_links[i] != link) { + rl.sls = ss7->mtp2_links[i]->slc; + return mtp3_transmit_int(ss7, SIG_NET_MNG, rl, 3, m); } - if (i == ss7->numlinks && link->std_test_passed) { + if (i == ss7->num_mtp2_links && link->std_test_passed) { rl.sls = link->slc; - return mtp3_transmit(ss7, SIG_NET_MNG, rl, 3, m); /* if no available another links */ + return mtp3_transmit_int(ss7, SIG_NET_MNG, rl, 3, m); /* if no available another links */ } } else { if (link->std_test_passed) { rl.sls = link->slc; - return mtp3_transmit(ss7, SIG_NET_MNG, rl, 3, m); + return mtp3_transmit_int(ss7, SIG_NET_MNG, rl, 3, m); } else { /* we may use another link to the same adjacent sp */ for (i = 0; i < link->adj_sp->numlinks; i++) { if (link->adj_sp->links[i]->std_test_passed) { rl.sls = link->adj_sp->links[i]->slc; - return mtp3_transmit(ss7, SIG_NET_MNG, rl, 3, m); + return mtp3_transmit_int(ss7, SIG_NET_MNG, rl, 3, m); } } } @@ -1571,7 +1607,7 @@ static void mtp3_link_failed(struct mtp2 *link) { link->std_test_passed = 0; - if (link->master->numlinks > 1 && available_links(link->master, -1, 1) && + if (link->master->num_mtp2_links > 1 && available_links(link->master, -1, 1) && (link->changeover == NO_CHANGEOVER || link->changeover == CHANGEBACK)) { AUTORL(rl, link); mtp3_prepare_changeover(link); @@ -1631,9 +1667,9 @@ return -1; } - layer4 = ss7_msg_userpart(m); + layer4 = ss7_msg_userpart(MTP3_ROUTE, m); - rllen = set_routinglabel(layer4, &drl); + rllen = mtp3_set_routinglabel(layer4, &drl); layer4 += rllen; testpatsize = (headerptr[1] >> 4) & 0xf; @@ -1643,9 +1679,9 @@ layer4[1] = (testpatsize << 4); memcpy(&layer4[2], &headerptr[2], testpatsize); - ss7_msg_userpart_len(m, rllen + testpatsize + 2); + ss7_msg_userpart_len(MTP3_ROUTE, m, rllen + testpatsize + 2); - mtp3_transmit(ss7, (ss7->switchtype == SS7_ITU) ? SIG_STD_TEST : SIG_SPEC_TEST, drl, 3, m); + mtp3_transmit_int(ss7, (ss7->switchtype == SS7_ITU) ? SIG_STD_TEST : SIG_SPEC_TEST, drl, 3, m); /* Update linkstate */ mtp3_setstate_mtp2link(ss7, mtp2, MTP2_LINKSTATE_UP); @@ -1702,58 +1738,51 @@ return 0; } -static struct mtp2 * rl_to_mtp2_nomtp3check(struct ss7 *ss7, struct routing_label rl) -{ - int i = 0; - struct mtp2 *link = NULL; - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->slc == rl.sls && (ss7->links[i]->adj_sp->adjpc == rl.dpc)) { - link = ss7->links[i]; - break; - } - } - - return link; -} - -int mtp3_transmit(struct ss7 *ss7, unsigned char userpart, struct routing_label rl, int priority, struct ss7_msg *m) +int mtp3_transmit(struct ss7 *ss7, struct ss7_route rt, unsigned char userpart, int priority, struct ss7_msg *m) { unsigned char *sio; - unsigned char *sif; - struct mtp2 *winner; - struct ss7_msg **buffer = NULL; + unsigned char *sif; + struct mtp2 *winner = rt.link; + struct ss7_msg **buffer = rt.data; - sio = m->buf + MTP2_SIZE; - sif = sio + 1; + + sio = m->buf + MTP2_SIZE; + sif = sio + 1; - if (userpart == SIG_ISUP) - winner = rl_to_link(ss7, rl, &buffer); - else - winner = rl_to_mtp2_nomtp3check(ss7, rl); - if (ss7->switchtype == SS7_ITU) - (*sio) = (ss7->ni << 6) | userpart; - else - (*sio) = (ss7->ni << 6) | (priority << 4) | userpart; + if (ss7->switchtype == SS7_ITU) + (*sio) = (ss7->ni << 6) | userpart; + else + (*sio) = (ss7->ni << 6) | (priority << 4) | userpart; - if (winner) { - if (winner->flags & MTP2_FLAG_TCP) { - return isup_ip_msu(winner, m); - } + if (winner) { + if (winner->flags & MTP2_FLAG_TCP) { + return isup_ip_msu(winner, m); + } - if (buffer) - return mtp3_to_buffer(buffer, m); - else - return mtp2_msu(winner, m); - } else { - ss7_error(ss7, "No siganlling link available sending message!\n"); - free(m); - return -1; - } + if (buffer) + return mtp3_to_buffer(buffer, m); + else + return mtp2_msu(winner, m); + } else { + ss7_error(ss7, "No signalling link available sending message!\n"); + free(m); + return -1; + } + } +/* This one only used internally. */ +static inline int mtp3_transmit_int(struct ss7 *ss7, unsigned char userpart, struct routing_label rl, int priority, struct ss7_msg *m) +{ + struct ss7_route rt = {.type = MTP3_ROUTE, .link = NULL, .data = NULL}; + + mtp3_rl_to_link(ss7, rl, userpart, &rt); + return mtp3_transmit(ss7, rt, userpart, priority, m); +} + int mtp3_dump(struct ss7 *ss7, struct mtp2 *link, void *msg, int len) { unsigned char *buf = (unsigned char *)msg; @@ -1828,11 +1857,11 @@ return -1; } - memcpy(ss7_msg_userpart(m), msg + 1, len - 1); + memcpy(ss7_msg_userpart(MTP3_ROUTE, m), msg + 1, len - 1); - ss7_msg_userpart_len(m, len); + ss7_msg_userpart_len(MTP3_ROUTE, m, len); - if (mtp3_transmit(ss7, (*sio) & 0xf, rl, get_priority(*sio), m)) { + if (mtp3_transmit_int(ss7, (*sio) & 0xf, rl, get_priority(*sio), m)) { mtp_error(ss7, "Unable to transmit message to be forwarded\n"); return -1; } @@ -1849,26 +1878,27 @@ /* Pass it to the correct user part */ switch (userpart) { - case SIG_STD_TEST: - case SIG_SPEC_TEST: - return std_test_receive(ss7, link, sif, siflen); - case SIG_ISUP: - /* Skip the routing label */ + case SIG_STD_TEST: + case SIG_SPEC_TEST: + return std_test_receive(ss7, link, sif, siflen); + case SIG_ISUP: + /* Skip the routing label */ #if 0 - if (link->adj_sp->state == MTP3_UP) - return isup_receive(ss7, link, &rl, sif + rlsize, siflen - rlsize); - else { - ss7_error(ss7, "Got ISUP message on link while MTP3 state is not UP!\n"); - return 0; - } + if (link->adj_sp->state == MTP3_UP) + return isup_receive(ss7, &rl, sif + rlsize, siflen - rlsize); + else { + ss7_error(ss7, "Got ISUP message on link while MTP3 state is not UP!\n"); + return 0; + } #endif - return isup_receive(ss7, link, &rl, sif + rlsize, siflen - rlsize); - case SIG_NET_MNG: - return net_mng_receive(ss7, link, &rl, sif, siflen); - case SIG_SCCP: - default: + return isup_receive(ss7, &rl, sif + rlsize, siflen - rlsize); + case SIG_NET_MNG: + return net_mng_receive(ss7, link, &rl, sif, siflen); + case SIG_SCCP: + default: + if (ss7_userpart_receive(ss7, rl, userpart, sif + rlsize, siflen - rlsize) < 0) mtp_message(ss7, "Unable to process message destined for userpart %d; dropping message\n", userpart); - return 0; + return 0; } } @@ -1886,9 +1916,9 @@ int i = 0; struct mtp2 *link = NULL; - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->slc == slc) - link = ss7->links[i]; + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i]->slc == slc) + link = ss7->mtp2_links[i]; } return link; @@ -1899,9 +1929,9 @@ struct mtp2 *link = NULL; int i; - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->fd == fd) { - link = ss7->links[i]; + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i]->fd == fd) { + link = ss7->mtp2_links[i]; break; } } @@ -1939,10 +1969,10 @@ { int i; - for (i = 0; i < ss7->numlinks; i++) { + for (i = 0; i < ss7->num_mtp2_links; i++) { if ((ss7->mtp2_linkstate[i] == MTP2_LINKSTATE_DOWN)) { - if (!(ss7->links[i]->flags & MTP2_FLAG_TCP)) { - mtp2_start(ss7->links[i], 1); + if (!(ss7->mtp2_links[i]->flags & MTP2_FLAG_TCP)) { + mtp2_start(ss7->mtp2_links[i], 1); } ss7->mtp2_linkstate[i] = MTP2_LINKSTATE_ALIGNING; } @@ -1957,16 +1987,16 @@ int winner = -1; if (fd > -1) { - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->fd == fd) { + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i]->fd == fd) { winner = i; break; } } if (winner > -1) { ss7->mtp2_linkstate[winner] = MTP2_LINKSTATE_INALARM; - mtp2_alarm(ss7->links[winner]); - mtp3_link_failed(ss7->links[winner]); + mtp2_alarm(ss7->mtp2_links[winner]); + mtp3_link_failed(ss7->mtp2_links[winner]); } } ss7_check(ss7); @@ -1978,16 +2008,16 @@ int i; int winner = -1; - for (i = 0; i < ss7->numlinks; i++) { - if (ss7->links[i]->fd == fd) { + for (i = 0; i < ss7->num_mtp2_links; i++) { + if (ss7->mtp2_links[i]->fd == fd) { winner = i; break; } } if (winner > -1) { ss7->mtp2_linkstate[winner] = MTP2_LINKSTATE_ALIGNING; - mtp2_noalarm(ss7->links[winner]); - mtp2_start(ss7->links[winner], 1); + mtp2_noalarm(ss7->mtp2_links[winner]); + mtp2_start(ss7->mtp2_links[winner], 1); } } @@ -2144,7 +2174,7 @@ { struct adjacent_sp *new; - if (ss7->numsps == SS7_MAX_ADJSPS) { + if (ss7->num_mtp2_sps == SS7_MAX_ADJSPS) { ss7_error(ss7, "Couldn't add new adjacent sp, reached the %i limit", SS7_MAX_ADJSPS); return; } @@ -2157,7 +2187,7 @@ return; } - ss7->adj_sps[ss7->numsps] = new; + ss7->adj_mtp2_sps[ss7->num_mtp2_sps] = new; new->timer_t19 = -1; new->timer_t21 = -1; @@ -2166,7 +2196,7 @@ new->numlinks = 1; new->adjpc = link->dpc; link->adj_sp = new; - ss7->numsps++; + ss7->num_mtp2_sps++; } void mtp3_add_adj_sp(struct mtp2 *link) @@ -2174,14 +2204,14 @@ struct ss7 *ss7 = link->master; int i; - for (i = 0; i < ss7->numsps; i++) { - if (ss7->adj_sps[i] && link->dpc == ss7->adj_sps[i]->adjpc) { - mtp3_add_link_adjsps(ss7->adj_sps[i], link); + for (i = 0; i < ss7->num_mtp2_sps; i++) { + if (ss7->adj_mtp2_sps[i] && link->dpc == ss7->adj_mtp2_sps[i]->adjpc) { + mtp3_add_link_adjsps(ss7->adj_mtp2_sps[i], link); break; } } - if (i == ss7->numsps) + if (i == ss7->num_mtp2_sps) mtp3_new_adjsp(ss7, link); } Index: isup.h =================================================================== --- isup.h (revision 266) +++ isup.h (working copy) @@ -272,7 +272,7 @@ int timer[ISUP_MAX_TIMERS]; }; -int isup_receive(struct ss7 *ss7, struct mtp2 *sl, struct routing_label *rl, unsigned char *sif, int len); +int isup_receive(struct ss7 *ss7, struct routing_label *rl, unsigned char *sif, int len); int isup_dump(struct ss7 *ss7, struct mtp2 *sl, unsigned char *sif, int len); Index: mtp3.h =================================================================== --- mtp3.h (revision 266) +++ mtp3.h (working copy) @@ -194,8 +194,10 @@ int mtp3_dump(struct ss7 *ss7, struct mtp2 *link, void *msg, int len); +/* Convert routing label to an ss7 route, return -1 on error/no link */ +int mtp3_rl_to_link(struct ss7 *ss7, struct routing_label rl, int userpart, struct ss7_route *rt); /* Transmit */ -int mtp3_transmit(struct ss7 *ss7, unsigned char userpart, struct routing_label rl, int priority, struct ss7_msg *m); +int mtp3_transmit(struct ss7 *ss7, struct ss7_route rt, unsigned char userpart, int priority, struct ss7_msg *m); void mtp3_alarm(struct ss7 *ss7, int fd); @@ -205,7 +207,7 @@ unsigned char ansi_sls_next(struct ss7 *ss7); -int set_routinglabel(unsigned char *sif, struct routing_label *rl); +int mtp3_set_routinglabel(unsigned char *sif, struct routing_label *rl); unsigned char sls_next(struct ss7 *ss7); Index: Makefile =================================================================== --- Makefile (revision 266) +++ Makefile (working copy) @@ -7,21 +7,36 @@ INSTALL_PREFIX=$(DESTDIR) INSTALL_BASE=/usr libdir?=$(INSTALL_BASE)/lib -STATIC_OBJS=mtp2.o ss7_sched.o ss7.o mtp3.o isup.o version.o isup_masq.o -DYNAMIC_OBJS=mtp2.o ss7_sched.o ss7.o mtp3.o isup.o version.o isup_masq.o +STATIC_OBJS=mtp2.o ss7_sched.o ss7.o mtp3.o isup.o version.o isup_masq.o m3ua.o +DYNAMIC_OBJS=mtp2.o ss7_sched.o ss7.o mtp3.o isup.o version.o isup_masq.o m3ua.o STATIC_LIBRARY=libss7.a DYNAMIC_LIBRARY=libss7.so.1.0 -CFLAGS=-Wall -Werror -Wstrict-prototypes -Wmissing-prototypes -g -fPIC +CFLAGS= -Wall -Werror -Wstrict-prototypes -Wmissing-prototypes -g -fPIC LDCONFIG_FLAGS=-n -SOFLAGS=-Wl,-hlibss7.so.1 -LDCONFIG=/sbin/ldconfig -#UTILITIES=parser_debug +ifeq ($(OSARCH),Darwin) + SOFLAGS=-dynamiclib -Wl,-flat_namespace,-undefined,suppress + LIB_EXT=dylib + CFLAGS+=-DDARWIN=1 + LDCONFIG=true # Don't care! +else + LDCONFIG=/sbin/ldconfig + SOFLAGS=-shared + LIB_EXT=so +endif +UTILITIES=parser_debug m3uatest + ifneq ($(wildcard /usr/include/dahdi/user.h),) UTILITIES+=ss7test ss7linktest endif +#check for sctp lib +ifneq ($(wildcard /usr/include/netinet/sctp.h),) +CFLAGS+=-DWITH_SCTP +SCTPLIB=-lsctp +endif + export SS7VERSION SS7VERSION:=$(shell GREP=$(GREP) AWK=$(AWK) build_tools/make_version .) @@ -38,7 +53,7 @@ clean: rm -f *.o *.so *.lo *.so.1 *.so.1.0 - rm -f parser_debug ss7linktest ss7test $(STATIC_LIBRARY) $(DYNAMIC_LIBRARY) + rm -f m3uatest parser_debug ss7linktest ss7test $(STATIC_LIBRARY) $(DYNAMIC_LIBRARY) rm -f .*.d install: $(STATIC_LIBRARY) $(DYNAMIC_LIBRARY) @@ -66,16 +81,19 @@ @rm -f $@.tmp ss7test: ss7test.c $(STATIC_LIBRARY) - gcc -g -o ss7test ss7test.c libss7.a -lpthread + gcc -g -o ss7test ss7test.c libss7.a -lpthread $(SCTPLIB) ss7linktest: ss7linktest.c $(STATIC_LIBRARY) - gcc -g -o ss7linktest ss7linktest.c libss7.a -lpthread + gcc -g -o ss7linktest ss7linktest.c libss7.a -lpthread $(SCTPLIB) parser_debug: parser_debug.c $(STATIC_LIBRARY) - gcc -g -Wall -o parser_debug parser_debug.c libss7.a + gcc -g -Wall -o parser_debug parser_debug.c libss7.a $(SCTPLIB) -libss7: ss7_mtp.o mtp.o ss7.o ss7_sched.o +m3uatest: m3uatest.o $(STATIC_LIBRARY) + gcc -g -o $@ m3uatest.o $(STATIC_LIBRARY) $(SCTPLIB) +libss7: ss7_mtp.o mtp.o ss7.o ss7_sched.ohi + .PHONY: FORCE: