def __init__(self,XMLCFG):		
    try:	
      Msg = "Prepare SCTP Server ..."
      PCA_GenLib.WriteLog(Msg,9)
      self.XMLCFG = XMLCFG	
      Tag = "LISTEN_HOST"
      host = PCA_XMLParser.GetXMLTagValue(XMLCFG,Tag)
      self.host = host		
			
      Tag = "LISTEN_PORT"
      port = PCA_XMLParser.GetXMLTagValue(XMLCFG,Tag)
      self.port = string.atoi(port)
			
      Msg = "Listen Host=<%s>,Port=<%s>" % (self.host,self.port)
      PCA_GenLib.WriteLog(Msg,1)
      self.SocketConnectionPool, self.ReadSet = [], []

      SocketDescriptor = sctp.sctpsocket_tcp(socket.AF_INET)
      if self.host == "any":
        SocketDescriptor.bind(("", self.port))
      else:
        SocketDescriptor.bind((self.host, self.port))
      SocketDescriptor.listen(5)
      self.SocketConnectionPool.append(SocketDescriptor) # add to main list to identify
      self.ReadSet.append(SocketDescriptor)    
    except :
      Msg = "SelectServer Initial error : <%s>,<%s> " % (sys.exc_type,sys.exc_value)
      PCA_GenLib.WriteLog(Msg,0)			
      raise
Exemplo n.º 2
0
    def __init__(self, XMLCFG):
        try:
            Msg = "Writer Init "
            PCA_GenLib.WriteLog(Msg, 9)

            self.TCAPMessage = PCA_TCAPMessage.Writer(XMLCFG)

            Tag = "MESSAGE_TYPE"
            self.message_type = int(PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag))

            Tag = "GT"
            self.GT = PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag)
            Msg = "GT = <%s> " % self.GT

            PCA_GenLib.WriteLog(Msg, 1)
            Tag = "SC_ADDRESS"
            self.sc_address = PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag)
            Msg = "sc_address = <%s> " % self.sc_address
            PCA_GenLib.WriteLog(Msg, 1)

            Tag = "FSG_GT"
            self.FSG_GT = PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag)

            Msg = "Writer OK"
            PCA_GenLib.WriteLog(Msg, 9)
        except:
            Msg = "Writer Init Error : <%s>,<%s> " % (sys.exc_type,
                                                      sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 3
0
    def characters(self, content):
        try:

            Msg = "characters Init "
            PCA_GenLib.WriteLog(Msg, 9)
            self.MAP_Message[self.MessageName] = (content, self.attrs)

            Msg = "%-20s=<%-25s>,Hex=%s" % (self.MessageName, content,
                                            PCA_GenLib.HexDump(self.attrs))
            PCA_GenLib.WriteLog(Msg, 3)
            Msg = "%s=%s" % (self.MessageName, content)
            PCA_GenLib.WriteLog(Msg, 1)
            if self.MessageName == "MAP opCode":
                self.opCode = content
            elif self.MessageName == "MAP imsi value":
                self.imsi = content
            elif self.MessageName == "MAP NNN value":
                self.NNN = content

            Msg = "characters OK"
            PCA_GenLib.WriteLog(Msg, 9)

        except:
            Msg = "characters Error :<%s>,<%s>" % (sys.exc_type, sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
    def __init__(self, XMLCFG):
        try:
            Msg = "ResponseHandler Init ..."
            PCA_GenLib.WriteLog(Msg, 9)

            PCA_ServerSocket.Acceptor.__init__(self, XMLCFG)
            Tag = "Handler"
            dll_file_name = PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag)
            Msg = "dll_file_name=<%s> " % dll_file_name
            PCA_GenLib.WriteLog(Msg, 0)

            Script_File = PCA_DLL.DLL(dll_file_name)

            factory_function = "Parser"
            factory_component = Script_File.symbol(factory_function)
            self.parser = factory_component()
            factory_function = "Handler"
            factory_component = Script_File.symbol(factory_function)
            self.handler = factory_component()
            self.parser.setContentHandler(self.handler)

            Tag = "Routing"
            self.msg_routing = PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag)
            Msg = "msg_routing = <%s> " % self.msg_routing
            PCA_GenLib.WriteLog(Msg, 0)

            Msg = "ResponseHandler Ok ..."
            PCA_GenLib.WriteLog(Msg, 9)
        except:
            Msg = "ResponseHandler error : <%s>,<%s> " % (sys.exc_type,
                                                          sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 5
0
    def symbol(self, symbol_name):
        try:
            Msg = "symbol init..."
            PCA_GenLib.WriteLog(Msg, 9)

            Msg = "synmol name = <%s>" % symbol_name
            PCA_GenLib.WriteLog(Msg, 9)

            ## This will return a handle point to
            ##  symbol_name (class in file ) in self.handle(python file name)
            #return self.importName(self.handle,symbol_name)
            module = __import__(self.python_file_name_)
            reload(module)

            self.handle = self.importName(self.python_file_name_, symbol_name)

            Msg = "symbol OK..."
            PCA_GenLib.WriteLog(Msg, 9)

            return self.handle

        except:
            Msg = "symbol error : <%s>,<%s> " % (sys.exc_type, sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 6
0
    def parse(self, source):
        try:
            Msg = "parser init"
            PCA_GenLib.WriteLog(Msg, 9)
            self.SOURCD_ID = 'HeartBeat'
            self.DebugStr = ' '
            orig_data = source
            name = 'none'
            self.StartParsing = 1

            if self.StartParsing == 1:
                self._cont_handler.endDocument(self.DebugStr, self.TID,
                                               self.SOURCD_ID)

            Msg = "parser OK"
            PCA_GenLib.WriteLog(Msg, 9)
        except:
            Msg = "parser  :<%s>,<%s>,name=<%s>" % (sys.exc_type,
                                                    sys.exc_value, name)
            PCA_GenLib.WriteLog(Msg, 0)

            Msg = "orig data =\n%s" % PCA_GenLib.HexDump(orig_data)
            PCA_GenLib.WriteLog(Msg, 0)

            Msg = "rest data =\n%s" % PCA_GenLib.HexDump(source)
            PCA_GenLib.WriteLog(Msg, 0)
            if self.StartParsing == 1:
                self._cont_handler.endDocument(self.DebugStr, self.TID,
                                               self.SOURCD_ID)
            return
	def __init__(self,XMLCFG,Tag):
		try:
			Msg = "File_Reader Init "
			PCA_GenLib.WriteLog(Msg,9)			
			
			Msg = "Your Tag  = <%s>" % (Tag)
			PCA_GenLib.WriteLog(Msg,8)						
			
			self.Tag = Tag
			
			self.StartTag = "<%s%s>" % (self.Tag,self.SEQ_NO)
			self.EndTag = "</%s%s>" % (self.Tag,self.SEQ_NO)
			
			Msg = "Your XMLCFG  = <%s>" % (XMLCFG)
			PCA_GenLib.WriteLog(Msg,8)
			
			self.XMLCFG = XMLCFG
			
			
			Msg = "File_Reader Init OK"
			PCA_GenLib.WriteLog(Msg,9)
		except:
			Msg = "File_Reader Init Error : <%s>,<%s> " % (sys.exc_type,sys.exc_value)
			PCA_GenLib.WriteLog(Msg,0)	
			raise
Exemplo n.º 8
0
    def sendDataToSocket(self, Message, TimeOutSeconds=0.2):
        try:
            Msg = "sendDataToSocket "
            PCA_GenLib.WriteLog(Msg, 9)

            WriteAttempts = 3

            for i in range(WriteAttempts):
                readables, writeables, exceptions = select([], self.WriteSet,
                                                           [], TimeOutSeconds)
                for SocketFD in writeables:
                    if (SocketFD == self.AcceptorConnection):
                        SocketFD.send(Message)
                        Msg = "sendDataToSocket OK"
                        PCA_GenLib.WriteLog(Msg, 9)
                        return 1
            Msg = "sendDataToSocket error ,Time out !"
            PCA_GenLib.WriteLog(Msg, 7)
            return None
        except socket.error:
            Msg = "sendDataToSocket socket error : <%s>,<%s> " % (
                sys.exc_type, sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise socket.error
        except:
            Msg = "sendDataToSocket error : <%s>,<%s> " % (sys.exc_type,
                                                           sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 9
0
    def sendDataToSocket(self, Message, TimeOutSeconds=0.5, WriteAttempts=1):
        try:
            Msg = "sendDataToSocket "
            PCA_GenLib.WriteLog(Msg, 9)

            WriteAttempts = 1
            self.WriteSet = []

            self.WriteSet.append(
                self.SocketDescriptor)  # add to select inputs list

            for i in range(WriteAttempts):
                readables, writeables, exceptions = select.select(
                    [], self.WriteSet, [], TimeOutSeconds)
                for SocketConnection in writeables:
                    if (SocketConnection == self.SocketDescriptor):

                        SocketConnection.send(Message)
                        Msg = "sendDataToSocket OK"
                        PCA_GenLib.WriteLog(Msg, 9)
                        return 1

            Msg = "sendDataToSocket error ,Time out !"
            PCA_GenLib.WriteLog(Msg, 7)
            #raise socket.error,"send time out"
            return None
        except:
            Msg = "sendDataToSocket error : <%s>,<%s> " % (sys.exc_type,
                                                           sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 10
0
    def startElement(self, name, attrs):
        try:
            Msg = "startElement init"
            PCA_GenLib.WriteLog(Msg, 9)

            #Msg = "name=<%s>,attrs=<%s>" % (name,PCA_GenLib.HexDump(attrs))
            #PCA_GenLib.WriteLog(Msg,0)
            name = "MAP %s" % name
            self.MessageName = name
            self.attrs = attrs
            if name == "version":
                self.version = attrs
            elif name == "otid":
                self.tcap_otid = attrs
            elif self.MessageName == "MAP imsi":
                self.imsi = content
            elif self.MessageName == "MAP NNN":
                self.NNN = content

            Msg = "startElement OK"
            PCA_GenLib.WriteLog(Msg, 9)
        except:
            Msg = "startElement Error :<%s>,<%s>" % (sys.exc_type,
                                                     sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 11
0
    def getHandlerResponse(self):
        try:
            Msg = "getHandlerResponse Init "
            PCA_GenLib.WriteLog(Msg, 9)

            Msg = "Traffic Type = <%s> " % self.Traffic_Type
            PCA_GenLib.WriteLog(Msg, 2)

            Protocol_Class = chr(0x80)

            hoop_counter = chr(0x0f)
            P_2_first_parameter = chr(0x04)
            # CgPA
            TT = self.SCCP_Message["SCCP called Translation Type"][1]
            Numbering_plan = self.SCCP_Message["SCCP called Numbering plan"][1]
            NoA = self.SCCP_Message["SCCP called Nature of Addr"][1]
            Digits = self.SCCP_Message["SCCP called Digits"][1]
            GT = TT + Numbering_plan + NoA + Digits
            calling_address = self.SCCP_Message[
                "SCCP called Address Indicator"][1] + self.SCCP_Message[
                    "SCCP called SSN"][1] + GT
            len_of_calling_address_digits = len(Digits)

            option_parameter = chr(0x00)
            # CdPA
            TT = self.SCCP_Message["SCCP calling Translation Type"][1]
            Numbering_plan = self.SCCP_Message["SCCP calling Numbering plan"][
                1]
            NoA = self.SCCP_Message["SCCP calling Nature of Addr"][1]
            Digits = self.SCCP_Message["SCCP calling Digits"][1]
            len_of_called_address_digits = len(Digits)
            GT = TT + Numbering_plan + NoA + Digits
            called_address = self.SCCP_Message[
                "SCCP calling Address Indicator"][1] + self.SCCP_Message[
                    "SCCP calling SSN"][1] + GT

            called_address_hex_length = struct.pack("!B", len(called_address))
            calling_address_hex_length = struct.pack("!B",
                                                     len(calling_address))
            tcap_message = self.tcap_response_message
            tcap_message_hex_length = struct.pack("!B", len(tcap_message))

            P_2_second_parameter = struct.pack(
                "!b", 4 + 3 + len_of_called_address_digits + 2)
            P_2_third_parameter = struct.pack(
                "!b", 4 + 3 + len_of_called_address_digits + 2 + 5 +
                len_of_calling_address_digits)
            sccp_data = self.message_type + Protocol_Class + hoop_counter + P_2_first_parameter + P_2_second_parameter + P_2_third_parameter + option_parameter + called_address_hex_length + called_address + calling_address_hex_length + calling_address + tcap_message_hex_length + tcap_message

            self.Message = sccp_data

            Msg = "getHandlerResponse OK"
            PCA_GenLib.WriteLog(Msg, 9)

            return self.Message
        except:
            Msg = "getHandlerResponse  error : <%s>,<%s> " % (sys.exc_type,
                                                              sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 12
0
def SetMainTerminateFlag(flag):
    try:
        Msg = "SetMainTerminateFlag = <%s> " % flag
        PCA_GenLib.WriteLog(Msg, 7)
        TerminateMutex.acquire()

        global main_terminate_flag

        main_terminate_flag = flag

        Msg = "TerminateCondition.acquire"
        PCA_GenLib.WriteLog(Msg, 7)

        TerminateCondition.acquire()

        Msg = "TerminateCondition.notify"
        PCA_GenLib.WriteLog(Msg, 7)

        TerminateCondition.notify()
        TerminateCondition.release()

        TerminateMutex.release()

        return
    except:
        Msg = "SetMainTerminateFlag  Error :<%s>,<%s>" % (sys.exc_type,
                                                          sys.exc_value)
        PCA_GenLib.WriteLog(Msg, 0)
        raise
Exemplo n.º 13
0
  def getASP_Active(self):
    try:	
	
      version = PCA_M3UAParameters.version
      reserve = PCA_M3UAParameters.reserve
      message_class = PCA_M3UAParameters.ASPTM
      message_type = PCA_M3UAParameters.ASPAC
      M3UA_header = version + reserve + message_class + message_type
	  
      Tag = PCA_M3UAParameters.Traffic_Mode_Type_Tag
      Length = struct.pack("!H",8)
      Data = struct.pack("!i",PCA_M3UAParameters.LoadShare)
      Traffic_mode_type = Tag + Length + Data
	  
      Tag = PCA_M3UAParameters.Routing_Context_Tag
      Length = struct.pack("!H",8)
      Data = struct.pack("!i",self.routing_context)
      Routing_context = Tag + Length + Data
      Msg = "M3UA_ASUP_UP Routing Context = <%s>" % (self.routing_context)
      PCA_GenLib.WriteLog(Msg,0)
     
      M3UA_data = M3UA_header + Traffic_mode_type + Routing_context
      message_length = len(M3UA_data) + 4
      message_length_hex = struct.pack("!i",message_length)
	  
      M3UA_ASP_Active = M3UA_header + message_length_hex + Traffic_mode_type + Routing_context
	   
      return M3UA_ASP_Active
	  
    except:
     Msg = "getM3UA_ASUP_UP Error :<%s>,<%s>" % (sys.exc_type,sys.exc_value)
     PCA_GenLib.WriteLog(Msg,0)
     raise	
Exemplo n.º 14
0
    def getHandlerResponse(self):
        try:
            Msg = "getHandlerResponse Init "
            PCA_GenLib.WriteLog(Msg, 9)

            MAP_Tag = chr(0xa2)
            tag = chr(0x02)
            try:
                #tag_data = parameter_list["MAP invoke value"][1]
                tag_data = self.MAP_Message["MAP invoke_id"][1]
            except:
                tag_data = chr(0x7d)

            invoke_id = self.constructTLV(tag, tag_data)

            map_data = invoke_id

            message_length = len(map_data)
            message_length_hex = struct.pack("!b", message_length)

            map_message = MAP_Tag + message_length_hex + map_data
            self.Message = map_message

            Msg = "getHandlerResponse OK"
            PCA_GenLib.WriteLog(Msg, 9)

            return self.Message

        except:
            Msg = "getHandlerResponse  error : <%s>,<%s> " % (sys.exc_type,
                                                              sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 15
0
  def __init__(self,XMLCFG):
    try:
      Msg = "Writer Init "
      PCA_GenLib.WriteLog(Msg,9)
		
      #0                   1                   2                   3
      #0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
      #+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      #| Version       | Reserved      | Message Class | Message Type |
      #+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      #| Message Length                                               |
      #+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      #\ \
      #/ /

      self.SCCPMessage = PCA_SCCPMessage.Writer(XMLCFG)
      Tag = "ROUTING_CONTEXT"
      self.routing_context = string.atoi(PCA_XMLParser.GetXMLTagValue(XMLCFG,Tag))
      Tag = "OPC"
      self.opc = string.atoi(PCA_XMLParser.GetXMLTagValue(XMLCFG,Tag))
      Tag = "DPC"
      self.dpc = string.atoi(PCA_XMLParser.GetXMLTagValue(XMLCFG,Tag))

			
	
      Msg = "Writer OK"
      PCA_GenLib.WriteLog(Msg,9)
    except:
      Msg = "Writer Init Error : <%s>,<%s> " % (sys.exc_type,sys.exc_value)
      PCA_GenLib.WriteLog(Msg,0)	
      raise
  def MT(self,conn,NNN,imsi):
    global g_originator
    global g_text
    global g_sca
    try:
     Msg = "MT"
     PCA_GenLib.WriteLog(Msg,9)
     (originator_address,sca,sms_text_data) =   (g_originator,g_sca,g_text)
     imsi = "%sf" % imsi
     request_parameter_list = {}
     request_parameter_list['originator'] = (originator_address,originator_address)    
     request_parameter_list['imsi'] = (imsi,imsi)
     request_parameter_list['NNN'] = (NNN,NNN)
     request_parameter_list['sca'] = (sca,sca)
   
     (sms_text_length,sms_text) = smspdu.pdu.pack7bit(sms_text_data)

     request_parameter_list['sms_text'] = (sms_text,sms_text)
     request_parameter_list['sms_text_length'] = (sms_text_length,sms_text_length)

     Message = self.M3UAMessage.getPayloadData("MT-FSM",request_parameter_list,request_parameter_list)
     self.sendDataToSocket(conn,Message)
    
     Msg = "MT OK"
     PCA_GenLib.WriteLog(Msg,9)
    except:
     Msg = "MT Error :<%s>,<%s>" % (sys.exc_type,sys.exc_value)
     PCA_GenLib.WriteLog(Msg,0)
     raise
Exemplo n.º 17
0
    def sendDataToSocket(self,
                         SocketEventFD,
                         Message,
                         TimeOut=5.0,
                         WriteAttempts=1):
        try:
            Msg = "sendDataToSocket "
            PCA_GenLib.WriteLog(Msg, 9)

            for i in range(WriteAttempts):
                readables, writeables, exceptions = select([], self.WriteSet,
                                                           [], TimeOut)
                for SocketFD in writeables:
                    if (SocketFD == SocketEventFD):
                        #Msg = "Send :*%s*" % PCA_GenLib.HexDump(Message)
                        #PCA_GenLib.WriteLog(Msg,5)
                        SocketFD.send(Message)
                        Msg = "sendDataToSocket OK"
                        PCA_GenLib.WriteLog(Msg, 9)
                        return 1

            Msg = "sendDataToSocket error ,Time out !"
            PCA_GenLib.WriteLog(Msg, 1)
            return None
        except:
            Msg = "sendDataToSocket error : <%s>,<%s> " % (sys.exc_type,
                                                           sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            #SocketEventFD.close()
            raise
Exemplo n.º 18
0
    def characters(self, content):
        try:

            Msg = "characters Init "
            PCA_GenLib.WriteLog(Msg, 9)

            Msg = "%-20s=<%-25s>,Hex=%s" % (self.MessageName, content,
                                            PCA_GenLib.HexDump(self.attrs))
            PCA_GenLib.WriteLog(Msg, 3)

            try:
                if self.Message[self.MessageName] != None:
                    x = 1
                self.dup_tag = self.dup_tag + 1
                name = "%s %s" % (self.MessageName, self.dup_tag)
                self.Message[name] = (content, self.attrs)
            except:
                self.Message[self.MessageName] = (content, self.attrs)

            Msg = "characters OK"
            PCA_GenLib.WriteLog(Msg, 9)

        except:
            Msg = "characters Error :<%s>,<%s>" % (sys.exc_type, sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
  def readDataFromSocket(self,SocketFD , Length=1024,TimeOut = 1.0):
    try:
      Msg = "readDataFromSocket "
      PCA_GenLib.WriteLog(Msg,9)
			   				  		
      Message = SocketFD.recv(Length)  
      if not Message:
        Msg = "server close connection"
        PCA_GenLib.WriteLog(Msg,0)
        raise socket.error,"server close connection"
    
      Msg = "ReadDataFromSocket OK"
      PCA_GenLib.WriteLog(Msg,9)
      return Message
				
			
      #Msg = "ReadDataFromSocket retry time out !"
      #PCA_GenLib.WriteLog(Msg,3)
      #return None
			
    except socket.error:
      Msg = "ReadDataFromSocket socket error : <%s>,<%s> " % (sys.exc_type,sys.exc_value)
      PCA_GenLib.WriteLog(Msg,0)
      raise
	
    except:
      Msg = "ReadDataFromSocket error : <%s>,<%s> " % (sys.exc_type,sys.exc_value)
      PCA_GenLib.WriteLog(Msg,0)
      raise	
    def parseGSM0340_request(self, data):
        try:
            Msg = "parseGSM0340_request Init "
            PCA_GenLib.WriteLog(Msg, 9)
            Msg = "GSM 0340 data =\n%s" % PCA_GenLib.HexDump(data)
            PCA_GenLib.WriteLog(Msg, 3)

            gsm_0340_pdu = data
            tag = gsm_0340_pdu[0]
            TP_MR = gsm_0340_pdu[1]

            source = gsm_0340_pdu[2:]

            name = "GSM0340 recipient length"
            attrs = source[0]
            content = ord(attrs)
            tag_length = content
            tag_length = tag_length / 2

            self.set_handler(name, attrs, tag_length)

            source = source[1:]
            name = "GSM0340 recipient address"
            attrs = source[0:tag_length + 1]
            toa = PCA_GenLib.getHexString(attrs[1])
            #tag_value = "%s:%s" % (toa,PCA_GenLib.getHexBCDString(attrs[1:]))
            tag_value = "%s" % (PCA_GenLib.getHexBCDString(attrs[1:]))
            self.DebugStr = "%s,<%s>=<%s>" % (self.DebugStr, name, tag_value)
            self.set_handler(name, attrs, tag_value)

            source = source[tag_length + 1:]
            pid = source[0]
            dcs = source[1]
            validity_period = source[2]

            name = "GSM0340 user data length"
            attrs = source[3]
            content = ord(attrs)
            user_data_length = content
            #self.set_handler(name,attrs,content)

            source = source[4:]
            tag_name = "GSM0340 sms text"
            attrs = source[0:user_data_length]
            Msg = "PCA DEBUG MO Text = %s " % attrs
            PCA_GenLib.WriteLog(Msg, 2)
            tag_value = smspdu.pdu.unpack7bit(attrs)
            self.DebugStr = "%s,<%s>=<%s>" % (self.DebugStr, tag_name,
                                              tag_value)
            self.set_handler("sms text", attrs, tag_value)

            Msg = "parseGSM0340_request ok "
            PCA_GenLib.WriteLog(Msg, 9)

        except:
            Msg = "parseGSM0340_request error : <%s>,<%s>" % (sys.exc_type,
                                                              sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 3)
Exemplo n.º 21
0
  def parseGSM0340_request(self,data):
    try:
        Msg = "parseGSM0340_request Init "
        PCA_GenLib.WriteLog(Msg,9)
        Msg = "GSM 0340 data =\n%s" % PCA_GenLib.HexDump(data)
        PCA_GenLib.WriteLog(Msg,2)
      
        mt_fsm_gsm_0340_pdu = data
        tag = mt_fsm_gsm_0340_pdu[0]
       
        source = mt_fsm_gsm_0340_pdu[1:]

        name = "OA length"
	attrs = source[0]
	content = ord(attrs)
        tag_length = content
        tag_length = tag_length / 2       
        self.set_handler(name,attrs,tag_length)

        source = source[1:]
        name = "GSM0340 originating address"
	attrs = source[0:tag_length+1]
        toa = PCA_GenLib.getHexString(attrs[1])
        tag_value = "%s:%s" % (toa,PCA_GenLib.getHexBCDString(attrs[1:]))
        self.DebugStr = "%s,<%s>=<%s>" % (self.DebugStr,name,tag_value)
        self.set_handler(name,attrs,tag_value)
        
        source = source[tag_length+1:]
        pid = source[0]
        dcs = source[1]
        time_stamp = source[2:2+6]
        
        source = source[9:] 
        name = "GSM0340 user data length"
        attrs = source[0]
        content = ord(attrs)
        user_data_length = content
        self.set_handler(name,attrs,content)


        source = source[1:]
        tag_name = "GSM0340 sms text"
	attrs = source[0:user_data_length]
        #tag_value = PCA_GenLib.getHexString(attrs)
        tag_value = smspdu.pdu.unpack7bit(attrs)
        self.DebugStr = "%s,<%s>=<%s>" % (self.DebugStr,tag_name,tag_value)
        self.set_handler("sms text",attrs,content)

      
        Msg = "parseGSM0340_request ok "
        PCA_GenLib.WriteLog(Msg,9)

    except:
      Msg = "parseGSM0340_request error : <%s>,<%s>" % (sys.exc_type,sys.exc_value)
      PCA_GenLib.WriteLog(Msg,0)
      Msg = "parseGSM0340_request error source =\n%s" % PCA_GenLib.HexDump(source)
      PCA_GenLib.WriteLog(Msg,3)
Exemplo n.º 22
0
    def __init__(self, XMLCFG):
        try:
            Msg = "Connector init ..."
            PCA_GenLib.WriteLog(Msg, 9)

            self.XMLCFG = XMLCFG
            Tag = "REMOTE_HOST"
            host = PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag)

            Tag = "CONNECT_PORT"
            connect_port = PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag)

            self.host = host
            self.connect_port = string.atoi(connect_port)

            Msg = "Host=<%s>,Port=<%s>" % (self.host, self.connect_port)
            PCA_GenLib.WriteLog(Msg, 7)

            Msg = "Call Socket..."
            PCA_GenLib.WriteLog(Msg, 7)
            # make a TCP/IP spocket object
            self.SocketDescriptor = socket.socket(socket.AF_INET,
                                                  socket.SOCK_STREAM)

            #  /* Set SO_REUSEADDR socket option to allow socket reuse */
            self.SocketDescriptor.setsockopt(socket.SOL_SOCKET,
                                             socket.SO_REUSEADDR, 1)
            Msg = "setsockopt..SO_REUSEADDR."
            PCA_GenLib.WriteLog(Msg, 8)

            #   /* Set SO_KEEPALIVE socket option */
            self.SocketDescriptor.setsockopt(socket.SOL_SOCKET,
                                             socket.SO_KEEPALIVE, 1)
            Msg = "setsockopt...SO_KEEPALIVE"
            PCA_GenLib.WriteLog(Msg, 8)

            try:

                Tag = "BIND_PORT"
                bind_port = PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag)
                self.bind_port = string.atoi(bind_port)

                Msg = "bind port number = <%s>" % self.bind_port
                PCA_GenLib.WriteLog(Msg, 7)

                #self.SocketDescriptor.bind((self.host, self.bind_port))      # bind it to server port number
                #localhost = "127.0.0.1"
                self.SocketDescriptor.bind(
                    ('', self.bind_port))  # bind it to server port number
            except:
                Msg = "bind error..."
                PCA_GenLib.WriteLog(Msg, 8)

            Msg = "Connector OK."
            PCA_GenLib.WriteLog(Msg, 9)
        except:
            Msg = "Connector Initial error : <%s>,<%s> " % (sys.exc_type,
                                                            sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 23
0
 def readDataFromSocket(self,Length=1024,TimeOut = 2.0,ReadAttempts = 1):
     try:
         Msg = "readDataFromSocket "
         PCA_GenLib.WriteLog(Msg,9)
         
         self.ReadSet = []            
         self.ReadSet.append(self.SocketDescriptor)              # add to select inputs list 
         
         
         Msg = "Length to read = <%s>  " % Length
         PCA_GenLib.WriteLog(Msg,8)
         Msg = "TimeOut = <%s> Seconds " % TimeOut
         PCA_GenLib.WriteLog(Msg,8)            
         Msg = "ReadAttempts = <%s>  " % ReadAttempts
         PCA_GenLib.WriteLog(Msg,8)
         
         for i in range(ReadAttempts):            
             readables, writeables, exceptions = select.select(self.ReadSet, [], [],TimeOut)
             for SocketFD in readables:
                 if (SocketFD == self.SocketDescriptor):
                     SMPP_Length = self.SocketDescriptor.recv(4)  
                     if not SMPP_Length:
                         Msg = "server close connection 1 "
                         PCA_GenLib.WriteLog(Msg,0)
                         raise socket.error,"server close connection 1"
                         
                     smpp_message_length = struct.unpack("!I",SMPP_Length)[0]  
                     SMPP_Data = self.SocketDescriptor.recv(smpp_message_length-4)  
                     if not SMPP_Data:
                         Msg = "server close connection 2"
                         PCA_GenLib.WriteLog(Msg,0)
                         raise socket.error,"server close connection 2"
                     
                     Message = SMPP_Length + SMPP_Data 
                     Msg = "ReadDataFromSocket OK"
                     PCA_GenLib.WriteLog(Msg,9)
                     return Message
         
         
         Msg = "ReadDataFromSocket retry time out !"
         PCA_GenLib.WriteLog(Msg,6)
         
         return None
         
     except socket.error:
         Msg = "readDataFromSocket socket error  reconnect: <%s>,<%s> " % (sys.exc_type,sys.exc_value)
         PCA_GenLib.WriteLog(Msg,0)
         raise socket.error
         
     except:
         Msg = "readDataFromSocket error : <%s>,<%s> " % (sys.exc_type,sys.exc_value)
         PCA_GenLib.WriteLog(Msg,0)
         self.Close()
         raise            
	def Close(self):
		try:
			Msg = "Close Init "
			PCA_GenLib.WriteLog(Msg,9)
			
			Msg = "Close OK"
			PCA_GenLib.WriteLog(Msg,9)
		except:
			Msg = "Close Error : <%s>,<%s> " % (sys.exc_type,sys.exc_value)
			PCA_GenLib.WriteLog(Msg,0)	
			raise
Exemplo n.º 25
0
    def endDocument(self, data, debugstr):
        try:

            self.DebugStr = debugstr
            Msg = "self.DebugStr=%s" % self.DebugStr
            PCA_GenLib.WriteLog(Msg, 1)

        except:
            Msg = "startElement Error :<%s>,<%s>" % (sys.exc_type,
                                                     sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 26
0
    def handle_timeout(self):
        try:
            Msg = "handle_timeout Init"
            PCA_GenLib.WriteLog(Msg, 9)

            Msg = "handle_timeout OK"
            PCA_GenLib.WriteLog(Msg, 9)
        except:
            Msg = "handle_timeout Error :<%s>,<%s>" % (sys.exc_type,
                                                       sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 27
0
    def Destory(self):
        try:
            Msg = "Destory init..."
            PCA_GenLib.WriteLog(Msg, 9)

            Msg = "Destory OK..."
            PCA_GenLib.WriteLog(Msg, 9)

        except:
            Msg = "Destory error : <%s>,<%s> " % (sys.exc_type, sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
Exemplo n.º 28
0
  def __init__(self,XMLCFG):
    try:
      Msg = "Writer Init "
      PCA_GenLib.WriteLog(Msg,9)

      self.MAPMessage = PCA_MAPMessage.Writer(XMLCFG)
      Msg = "Writer OK"
      PCA_GenLib.WriteLog(Msg,9)
    except:
      Msg = "Writer Init Error : <%s>,<%s> " % (sys.exc_type,sys.exc_value)
      PCA_GenLib.WriteLog(Msg,0)
      raise
Exemplo n.º 29
0
    def handle_event(self, SocketEventFD, ClientMessage):
        try:
            Msg = "handle_event Init"
            PCA_GenLib.WriteLog(Msg, 9)

            Msg = "handle_event OK"
            PCA_GenLib.WriteLog(Msg, 9)
        except:
            Msg = "handle_event Error :<%s>,<%s>" % (sys.exc_type,
                                                     sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise
    def __init__(self):
        try:
            Msg = "parser __init__"
            PCA_GenLib.WriteLog(Msg, 9)

            PCA_SMPPParser.Parser.__init__(self)

            Msg = "parser __init__ ok"
            PCA_GenLib.WriteLog(Msg, 9)
        except:
            Msg = "parser __init__  :<%s>,<%s>" % (sys.exc_type, sys.exc_value)
            PCA_GenLib.WriteLog(Msg, 0)
            raise