from utils import Parser
import utils
import ems, runtime
import config
from mms_net_define import *
from mms_net_pdu import Get_CurrentDate
import mmsconfig
#Message Type Indicator
MTI_DELIVER = MTI_DELIVER_REPORT = 0x0
MTI_SUBMIT = MTI_SUBMIT_REPORT = 0x1
MTI_COMMAND = MTI_STATUS_REPORT = 0x2
#port
# Multipart Message: 0x158A
# Caller Line Identification Icon Message - CLI Logo Message: 0x1583
# Operator Logo Reader: 0x1582
#
# PID Protocol-Identifier
# OA Originating-Address
# DA Destination-Address
# MR Message-Reference
# SRR Status-Report-Request
# SRI Status-Report-Indication
# VPF Validity-Period-Format
# MMS More-Messages-to-Send
# DCS Data-Coding-Scheme
# VP Validity-Period
# DT Discharge-Time
# RA Recipient-Address
# ST Status
# CDL Command-Data-Length
# CD Command-Data
# FCS Failure-Cause
# RP Reply-Path
# MN Message-Number
# CT Command-Type
# UDL User-Data-Length
# UDHI User-Data-Header-Indicator
# UD User-Data
# PI Parameter-Indicator
# SRQ Status-Report-Qualifier
# RD Reject-Duplicates
# SCTS Service-Centre-Time-Stamp
MTI_SHIFT = 0
MTI_MASK = 3
MMS_SHIFT = 2
MMS_MASK = 1
RD_SHIFT = 2
RD_MASK = 1
VPF_SHIFT = 3
VPF_MASK = 3
SRR_SHIFT = 5
SRR_MASK = 1
SRI_SHIFT = 5
SRI_MASK = 1
UDHI_SHIFT = 6
UDHI_MASK = 1
RP_SHIFT = 7
RP_MASK = 1
# RP : 0 no reply path
# 1 has reply path
#
# PID 0x20: telematic interworking
PID_NORMAL = 0x00
PID_FAX = 0x02 | 0x20
PID_EMAIL = 0x12 | 0x20
ENCODING_7, ENCODING_8, ENCODING_UCS2 = range(3)
class MultipartMessage:
# smart messaging spec: 3-31
# version, item-type
# length = 2 octet
# item type: 00 -> length, iso-8859-1
# 01 -> length unicode
# 02 -> length ota bitmap
# 03 -> length ring tone
# 04 -> length profile name
# 05 -> reserved
# 06 -> length screensaver
pass
def encode_semi_octet(octet):
enc = ''
i = 0
while i < len(octet) - 1:
enc += chr(octet[i] + octet[i+1] * 16)
i += 2
if i < len(octet):
enc += chr(octet[i] + 0xF * 16)
return enc
def decode_semi_octet(enc):
enc = [ord(x) for x in enc]
dec = ''
for x in enc:
dec += chr((x & 0xF) + ord('0'))
if (x >> 4) != 0xF:
dec += chr((x >> 4) + ord('0'))
return dec
def decode_scts(ts):
def decode(octet):
return (ord(octet) & 0xF) * 10 + (ord(octet) >> 4)
year = decode(ts[0])
mon = decode(ts[1])
day = decode(ts[2])
hour = decode(ts[3])
min = decode(ts[4])
sec = decode(ts[5])
tz = decode(ts[6])
return year, mon, day, hour, min, sec, tz
### START(060201) : Replaced by Ryoo Ho Chang ###
special_semi_octet_encode = (42, 35, 97, 98, 99)
special_semi_octet_decode = (10, 11, 12, 13, 14)
def encode_address(addr):
addr_type = 0x81
addr_len = len(addr)
addr_header = "%c%c" % (addr_len, addr_type)
addr = [ord(x) for x in addr]
addr_encode = ''
first_half_octet = 0
second_half_octet = 0
print 'addr = ', addr
i = 0
while i < len(addr) - 1:
if addr[i] in special_semi_octet_encode:
if addr[i] == 42: # '*'
second_half_octet = 10
elif addr[i] == 35: # '#'
second_half_octet = 11
elif addr[i] == 97: # 'a'
second_half_octet = 12
elif addr[i] == 98: # 'b'
second_half_octet = 13
elif addr[i] == 99: # 'c'
second_half_octet = 14
else:
second_half_octet = addr[i] - ord('0')
if addr[i+1] in special_semi_octet_encode:
if addr[i+1] == 42: # '*':
first_half_octet = 10
elif addr[i+1] == 35: # '#':
first_half_octet = 11
elif addr[i+1] == 97: # 'a':
first_half_octet = 12
elif addr[i+1] == 98: # 'b':
first_half_octet = 13
elif addr[i+1] == 99: # 'c':
first_half_octet = 14
else:
first_half_octet = addr[i+1] - ord('0')
addr_encode += chr(first_half_octet*16 + second_half_octet)
i += 2
if i < len(addr):
if addr[i] in special_semi_octet_encode:
if addr[i] == ord('*'):
last_half_octet = 10
elif addr[i] == '#':
last_half_octet = 11
elif addr[i] == 'a':
last_half_octet = 12
elif addr[i] == 'b':
last_half_octet = 13
elif addr[i] == 'c':
last_half_octet = 14
else:
last_half_octet = addr[i] - ord('0')
addr_encode += chr(0xF*16 + last_half_octet)
return addr_header + addr_encode
def decode_addr(addr_len, addr_type, addr_encode):
addr_encode = [ord(x) for x in addr_encode]
decoded_addr = ''
first_half_octet = 0
second_half_octet = 0
for x in addr_encode:
first_half_octet = x & 0xF
second_half_octet = x >> 4
if first_half_octet in special_semi_octet_decode:
if first_half_octet == 10:
decoded_addr += '*'
elif first_half_octet == 11:
decoded_addr += '#'
elif first_half_octet == 12:
decoded_addr += 'a'
elif first_half_octet == 13:
decoded_addr += 'b'
elif first_half_octet == 14:
decoded_addr += 'c'
else:
decoded_addr += chr(first_half_octet + ord('0'))
if second_half_octet in special_semi_octet_decode:
if second_half_octet == 10:
decoded_addr += '*'
elif second_half_octet == 11:
decoded_addr += '#'
elif second_half_octet == 12:
decoded_addr += 'a'
elif second_half_octet == 13:
decoded_addr += 'b'
elif second_half_octet == 14:
decoded_addr += 'c'
else:
if second_half_octet != 0xF:
decoded_addr += chr(second_half_octet + ord('0'))
return decoded_addr
### END(060201) ###
# DCS: 0xF1
# DCS & 0xC0 -> 0: general data coding indication
# DCS & 0x0C -> 0(7bit alphabet), 1(8 bit), 2(ucs2)
# DCS & 0x20 -> 1 compressed
# DCS & 0xF0 -> 0xF0: DCS & 0x4 -> 0(7bit alphabet), 1(8 bit)
# , 0x -> 7bit alphabet
#DCS_7BIT = 0xF0
DCS_7BIT = 0x00
# VPF
# User Data header: UDHL, IEI, IEIDL, IED, IEI, IEIDL, IED,
# VPF: 2 -> relative, 1 -> enhanced, 3 -> absolute
import status, modem
import emssplit
import gsm7
import mms_net_define
class SmsInfoHandler:
def __init__(self, info=None):
self.filename = ''
self.messageTime = ''
self.isRead = mms_net_define.NO
self.sender = ''
self.receiver = ''
self.smsMessageType = ''
self.smsSubject = ''
self.replyTo = ''
self.sipSubject = ''
if info:
self.saveInfo(info)
def printVar(self, number):
print '>>>> SmsInfoHandler ====> ', number
print 'self.filename = ', self.filename
print 'self.messageTime = ', self.messageTime
print 'self.isRead = ', self.isRead
print 'self.sender = ', self.sender
print 'self.receiver = ', self.receiver
print 'self.smsMessageType = ', self.smsMessageType
print 'self.smsSubject = ', self.smsSubject
print 'self.sipSubject = ', self.sipSubject
def getSipSubject(self):
return self.sipSubject
def setSipSubject(self, sipSubject):
self.sipSubject = sipSubject
def getReplyTo(self):
return self.replyTo
def setReplyTo(self, replyTo):
self.replyTo = replyTo
def getFilename(self):
return self.filename
def setFilename(self, filename):
self.filename = filename
def getMessageTime(self):
return self.messageTime
def getMessageTimeList(self):
if self.messageTime:
year = self.messageTime[:4]
month = self.messageTime[4:6]
date = self.messageTime[6:8]
hour = self.messageTime[8:10]
minute = self.messageTime[10:12]
second = self.messageTime[12:14]
return (year, month, date, hour, minute, second)
else:
return self.messageTime
def setMessageTime(self, messageTime):
self.messageTime = messageTime
def getIsRead(self):
return self.isRead
def setIsRead(self, isRead):
self.isRead = isRead
def getSender(self): # == mmsFrom
return self.sender
def setSender(self, sender):
self.sender = sender
def getReceiver(self):
return self.receiver
def setReceiver(self, receiver):
self.receiver = receiver
def getSmsMessageType(self):
return self.smsMessageType
def setSmsMessageType(self, smsMessageType):
self.smsMessageType = smsMessageType
def getSmsSubject(self):
return self.smsSubject
def setSmsSubject(self, smsSubject):
self.smsSubject = smsSubject
def makeTimeStamp(self):
import time
now = time.localtime()
now = now[:6]
now = '%04d%02d%02d%02d%02d%02d' % now
return now
def makeInfoList(self):
return (self.filename, self.messageTime, self.isRead, self.sender, self.replyTo, self.receiver, self.smsMessageType, self.smsSubject)
def saveInfo(self, info):
self.filename, self.messageTime, self.isRead, self.sender, self.replyTo, self.receiver, self.smsMessageType, self.smsSubject = info
def getBoxType(self):
import smsmanager
if self.filename:
if self.filename.find('received') > 0:
return smsmanager.IN_BOX
elif self.filename.find('saved') > 0:
return smsmanager.OUT_BOX
elif self.filename.find('draft') > 0:
return smsmanager.DRAFT_BOX
elif self.filename.find('sent') > 0:
return smsmanager.SENT_BOX
else:
print 'ERROR : getBoxType'
def copyTempToNormal(self, path, tempFile=None):
if not tempFile:
print 'ERROR in SAVE'
return
import os
i = 0
while True:
filename = path + '%08d' % i
if not os.path.exists(filename):
break
i += 1
continue
normalFile = os.path.normpath(filename)
self.filename = normalFile
os.rename(tempFile, normalFile)
class SmsSipHandler:
def __init__(self, sender='', sipContentType='', sipSubject='', sipAbsMessagePath='', sipReplyTo=''):
# hcryoo : [20071217_1] : KT ISMC 지원
self.sipIsmcHostname = '1549'
self.sipIsmcDomain = 'ismc.ann.com'
self.targetUserName = ''
self.targetHostName = ''
# hcryoo : [20071217_1] : KT ISMC 지원==
self.sipContentType = sipContentType
self.sipSubject = sipSubject
self.sipAbsMessagePath = sipAbsMessagePath
self.sipMessageString = ''
# hcryoo : [20071217_1] : KT ISMC 지원
self.sipReplyTo = sipReplyTo
# hcryoo : [20071217_1] : KT ISMC 지원==
self.senderName = sender
def printVar(self, number):
print '>>>> SmsSipHandler ====> ', number
print 'self.targetUserName = ', self.targetUserName
print 'self.targetHostName = ', self.targetHostName
print 'self.sipContentType = ', self.sipContentType
print 'self.sipSubject = ', self.sipSubject
print 'self.sipAbsMessagePath = ', self.sipAbsMessagePath
print 'self.sipReplyTo = ', self.sipReplyTo
# SIP
# hcryoo : [20071217_1] : KT ISMC 지원
def getSipIsmcHostname(self):
return self.sipIsmcHostname
def setSipIsmcHostname(self, sipIsmcHostname):
self.sipIsmcHostname = sipIsmcHostname
def getSipIsmcDomain(self):
return self.sipIsmcDomain
def setSipIsmcDomain(self, sipIsmcDomain):
self.sipIsmcDomain = sipIsmcDomain
def getTargetUserName(self):
return self.targetUserName
# hcryoo : [20071217_1] : KT ISMC 지원==
def setTargetUserName(self, targetUserName):
self.targetUserName = targetUserName
def getTargetHostName(self):
return self.targetHostName
def setTargetHostName(self, targetHostName):
self.targetHostName = targetHostName
def getTargetFullName(self):
if self.targetUserName:
return self.targetUserName + '@' + self.targetHostName
else:
return ''
def getSipContentType(self):
return self.sipContentType
def setSipContentType(self, sipContentType):
self.sipContentType = sipContentType
def getSipSubject(self):
return self.sipSubject
def setSipSubject(self, sipSubject):
self.sipSubject = sipSubject
def getSipAbsMessagePath(self):
return self.sipAbsMessagePath
def setSipAbsMessagePath(self, sipAbsMessagePath):
self.sipAbsMessagePath = sipAbsMessagePath
# hcryoo : [20071217_1] : KT ISMC 지원
def getSipReplyTo(self):
return self.sipReplyTo
def setSipReplyTo(self, sipReplyTo):
self.sipReplyTo = sipReplyTo
# hcryoo : [20071217_1] : KT ISMC 지원==
def getSenderName(self):
return self.senderName
def setSenderName(self, senderName):
self.senderName = senderName
def getSipDataAll(self):
return (self.targetUserName, self.targetHostName, self.sipContentType, \
self.sipSubject, self.sipAbsMessagePath, self.sipReplyTo, self.senderName)
def getSipMessageString(self):
fileHandle = open(self.sipAbsMessagePath, 'r')
self.sipMessageString = fileHandle.read()
fileHandle.close()
return self.sipMessageString
# hcryoo : [20071217_1] : KT ISMC 지원
class IsmcMessage_Receive(SmsSipHandler):
def __init__(self, smsSipHandler):
SmsSipHandler.__init__(self)
self.targetUserName, self.targetHostName, self.sipContentType, \
self.sipSubject, self.sipAbsMessagePath, self.sipReplyTo, self.senderName = smsSipHandler.getSipDataAll()
self.ismcMessageHandler = IsmcMessageHandler()
self.mmsMessageHandler.parse(self.sipAbsMessagePath)
self.mmsMessageHandler.mmsHeaderHandler.printVar(1)
def discard(self):
import os
filePath = self.getSipAbsMessagePath()
os.remove(filePath)
# hcryoo : [20071217_1] : KT ISMC 지원==
class SmsMessage_Receive(SmsSipHandler):
def __init__(self, smsSipHandler):
SmsSipHandler.__init__(self)
self.targetUserName, self.targetHostName, self.sipContentType, \
self.sipSubject, self.sipAbsMessagePath, self.senderName = smsSipHandler.getSipDataAll()
self.mmsMessageHandler = MmsMessageHandler()
self.mmsMessageHandler.parse(self.sipAbsMessagePath)
self.mmsMessageHandler.mmsHeaderHandler.printVar(1)
def discard(self):
import os
filePath = self.getSipAbsMessagePath()
os.remove(filePath)
# hcryoo : [20071217_1] : KT ISMC 지원
class SmsIsmcMessage_Send(SmsSipHandler):
def __init__(self, message):
SmsSipHandler.__init__(self)
self.ismcMessageHandler = message
def makeSipBodyFile(self):
filePath = self.ismcMessageHandler.makeIsmcBody(True)
self.setSipAbsMessagePath(filePath)
def send(self):
runtime.vdciapp.send_mesg(code1='m', code2='m', \
mesg1=self.getTargetUserName(), \
mesg2=self.getTargetHostName(), \
#mesg3=self.getSipContentType(), \
#mesg4=self.getSipSubject(), \
mesg5=self.getSipMessageString(), \
mesg6=self.getSipReplyTo(),\
mesg7=self.getSipIsmcHostname(), \
mesg8=self.getSipIsmcDomain())
def discard(self):
import os
filePath = self.getSipAbsMessagePath()
os.remove(filePath)
# hcryoo : [20071217_1] : KT ISMC 지원==
class SmsMessage_Send(SmsSipHandler):
def __init__(self, message):
SmsSipHandler.__init__(self)
self.mmsMessageHandler = message
self.headerList = []
def addHeaderName(self, headerName):
self.headerList.append(headerName)
def setHeaderList(self, headerList):
self.headerList = headerList
def makeSipBodyFile(self):
filePath = self.mmsMessageHandler.makeMmsMessage(self.headerList)
self.setSipAbsMessagePath(filePath)
def send(self):
runtime.vdciapp.send_mesg(code1='m', code2='m', \
mesg1=self.getTargetUserName(), \
mesg2=self.getTargetHostName(), \
mesg3=self.getSipContentType(), \
mesg4=self.getSipSubject(), \
mesg5=self.getSipAbsMessagePath())
def discard(self):
import os
filePath = self.getSipAbsMessagePath()
os.remove(filePath)
class M_Notification_Ind_SMS(SmsMessage_Receive):
def __init__(self, smsSipHandler):
SmsMessage_Receive.__init__(self, smsSipHandler)
def isSuccess(self):
if self.mmsResponseStatus == 'Success':
return True
else:
return False
# hcryoo : [20071217_1] : KT ISMC 지원
class M_Send_Conf_SMS(SmsMessage_Receive):
def __init__(self, smsSipHandler):
SmsMessage_Receive.__init__(self, smsSipHandler)
self.discard()
def isSuccess(self):
if self.mmsMessageHandler.mmsHeaderHandler.getMmsResponseStatus() == '100':
return True
else:
return False
# hcryoo : [20071217_1] : KT ISMC 지원==
'''
class M_Send_Conf_SMS(SmsMessage_Receive):
def __init__(self, smsSipHandler):
SmsMessage_Receive.__init__(self, smsSipHandler)
self.discard()
def isSuccess(self):
if self.mmsMessageHandler.mmsHeaderHandler.getMmsResponseStatus() == '100':
return True
else:
return False
'''
# hcryoo : [20071217_1] : KT ISMC 지원
class M_NotifyResp_Ind_SMS(SmsIsmcMessage_Send):
def __init__(self, message):
SmsIsmcMessage_Send .__init__(self, message)
# hcryoo : [20071217_1] : KT ISMC 지원==
'''
class M_NotifyResp_Ind_SMS(SmsMessage_Send):
def __init__(self, message):
SmsMessage_Send .__init__(self, message)
header = [X_Mms_Message_Type, X_Mms_Message_ID, X_Mms_Transaction_ID, \
X_Mms_MMS_Version, X_Mms_Status]
self.setHeaderList(header)
'''
# hcryoo : [20071217_1] : KT ISMC 지원
class M_Send_Req_ISMC_SMS(SmsIsmcMessage_Send):
def __init__(self, message):
SmsIsmcMessage_Send .__init__(self, message)
# hcryoo : [20071217_1] : KT ISMC 지원==
'''
class M_Send_Req_SMS(SmsMessage_Send):
def __init__(self, message):
SmsMessage_Send .__init__(self, message)
header = [X_Mms_Message_Type, X_Message_Type, X_Mms_Transaction_ID, \
X_Mms_MMS_Version, X_Mms_IP, X_Message_Callback, X_Mms_Explicit_No, \
From, To, Subject, X_Mms_Message_Class, X_Mms_Priority, X_Mms_Sender_Visibility, \
X_Mms_Delivery_Report, X_Mms_Read_Reply, X_Mms_Store, Content_Type]
self.setHeaderList(header)
'''
class Submit:
def __init__(self, type, number, contents, notify=0):
self.srr = notify
self.number = number
self.protocol_id = type
self.contents = contents
if type == 'email':
self.pid = PID_EMAIL
elif type == 'fax':
self.pid = PID_FAX
else:
self.pid = PID_NORMAL
self.number += status.callee_terminal_number
ems = emssplit.EmsSplit(contents)
self.segments = []
self.dcs = DCS_7BIT
for udh, p in ems.payloads:
if udh:
self.udhi = 1
else:
self.udhi = 0
header = self.make_header()
self.segments.append(header + p)
def make_header(self):
mti = MTI_SUBMIT
vpf = 0 # 0: not present, 2: relative
rp = rd = 0
header = []
flags = (mti << MTI_SHIFT) | (rd << RD_SHIFT) | \
(self.srr << SRR_SHIFT) | (vpf << VPF_SHIFT) | \
(self.udhi << UDHI_SHIFT) | (rp << RP_SHIFT)
header.append(flags)
status.message_reference = 0xff & (status.message_reference + 1)
mr = status.message_reference
header.append(mr)
addr = encode_address(self.number)
header.append(addr)
pid = self.pid
header.append(pid)
header.append(self.dcs)
# 0 to 143 (vp + 1) * 5 min
# 144 to 167 12hours + (vp - 143) * 30 min
# 168 to 196 (vp - 166) * 1 day
# 197 to 255 (vp - 192) * 1 week
if vpf:
vp = 0x03 # 20 min
header.append(vp)
s = ''
for h in header:
if type(h) == type(0):
h = chr(h)
s += h
return s
class DeliverReport:
def __init__(self, message):
self.udhi = 0
self.dcs = DCS_7BIT
self.segments = []
header = self.make_header()
#추가 메시지를 보내지않는다
#text = gsm7.gsm7bit_encode(message)
#content = chr(len(text)) + gsm7.gsm7_pack(text, 0)
content = ''
self.segments.append(header + content)
def make_header(self):
mti = MTI_DELIVER_REPORT
header = []
flags = (mti << MTI_SHIFT) | (self.udhi << UDHI_SHIFT)
header.append(flags)
header.append(0xd0) # failure cause: sms storage full
#user data가 있으면 3대신 7을 사용
header.append(3) # parameter indicator: has pid, dcs, user data
header.append(PID_NORMAL)
header.append(self.dcs)
s = ''
for h in header:
if type(h) == type(0):
h = chr(h)
s += h
return s
def get_sms_message_type(data):
flags = ord(data[0])
mti = (flags >> MTI_SHIFT) & MTI_MASK
if mti == MTI_DELIVER:
return 'deliver'
elif mti == MTI_SUBMIT_REPORT:
return 'report'
elif mti == MTI_STATUS_REPORT:
return 'status'
class Deliver(Parser):
def __init__(self, message):
Parser.__init__(self, message)
self.compress = False
self.contents = []
self.ems_contents = []
self.content_type = 'Text'
self.message_ref = 0
self.message_total_number = 1
self.message_seq = 1
self.bad_udl = False
self.udhl = 0
self.bMMSNoti = SMSMESSASGE
self.parse_header()
self.parse_user_data()
self.arrange_ems()
def IsMMSnotification(self):
userdata = self.raw_data[self.parse_pos:]
if (SMSMESSASGE == self.bMMSNoti or 1 != self.message_seq):
return
mmsheader_index = 0
#TransactionID: 0
mmsheader_index += 1
if 0x06 == ord(userdata[mmsheader_index]):
#print 'token for push pdu'
pass
else:
#print 'IsMMSnotification smsmessage'
self.bMMSNoti = SMSMESSASGE
return
mmsheader_index += 1
lengthofheader = ord(userdata[mmsheader_index])
mmsheader_index += 1
if (-1 == userdata.find('application/vnd.wap.mms-message')):
if 190 == ord(userdata[mmsheader_index]):
#print '190 application/vnd.wap.mms-message'
pass
else:
#print '== SPREE userdata.find -1 & !190'
self.bMMSNoti = SMSMESSASGE
return
mmsdata_index = lengthofheader + mmsheader_index#3
#print 'mmsdata_index', userdata[mmsdata_index:]
while (mmsdata_index < len(userdata)):
#print 'self.raw_data[mmsdata_index]', ord(userdata[mmsdata_index]), mmsdata_index
if (chr(int('8c', 16)) == userdata[mmsdata_index]):
if (chr(int('82', 16)) == userdata[mmsdata_index+1]):
#print 'MMS_Notification'
return
elif (chr(int('86', 16)) == userdata[mmsdata_index+1]):
#print 'MMS_Delivery'
self.bMMSNoti = MMSDELIVERY_IND
return
mmsdata_index += 1
return
def parse_header(self):
#print 'parse_header', ord(self.raw_data[0]), ord(self.raw_data[1]),\
ord(self.raw_data[2]), ord(self.raw_data[3]), ord(self.raw_data[4]), self.parse_pos
flags = self.get_byte()
#print 'pid pars_pos', self.parse_pos
self.mti = (flags >> MTI_SHIFT) & MTI_MASK
self.mms = (flags >> MMS_SHIFT) & MMS_MASK
self.sri = (flags >> SRI_SHIFT) & SRI_MASK
self.udhi = (flags >> UDHI_SHIFT) & UDHI_MASK
self.rp = (flags >> RP_SHIFT) & RP_MASK
#if self.udhi:
# print 'has user data header'
self.parse_addr()
#print 'parse_addr pars_pos', self.parse_pos
self.pid = self.get_byte()
#print 'pid', self.pid, self.raw_data[self.parse_pos-1], self.parse_pos
#print 'pid pars_pos', self.parse_pos
self.parse_dcs()
self.parse_scts()
def parse_dcs(self):
dcs = self.get_byte()
#print 'DCS: %02X' % dcs
if (dcs & 0xF0) == 0xF0:
if (dcs & 0x04) == 0:
self.encoding = ENCODING_7
#print 'dcs: 7bit alphabet'
else:
self.encoding = ENCODING_8
#print 'dcs: 8bit'
elif (dcs & 0xC0) == 0:
if (dcs & 0x0C) == 0:
self.encoding = ENCODING_7
#print 'dcs: 7bit alphabet'
elif (dcs & 0x0C) == 4:
self.encoding = ENCODING_8
#print 'dcs: 8bit data'
elif (dcs & 0x0C) == 8:
#print 'ucs2 encoding'
self.encoding = ENCODING_UCS2
if (dcs & 0x20):
#print 'FIXME: Data is compressed!!!'
self.compress = True
def parse_scts(self):
self.scts = decode_scts(self.get_data(7))
def parse_addr(self):
addr_len = self.get_byte()
addr_type = self.get_byte()
data = self.get_data((addr_len + 1)/2)
#print 'parse_addr', addr_len, addr_type, data
self.addr = decode_addr(addr_len, addr_type, data)
def parse_user_data_header(self):
udhl = self.get_byte()
#print 'user data header length', udhl
self.udhl = udhl
header_end = self.parse_pos + udhl
#print 'header_end', self.parse_pos , header_end
while self.parse_pos < header_end:
self.parse_ied()
def check_MMS_delivery(self):
#print 'check_MMS_delivery'
tmp_parse_pos = self.parse_pos
tmp_udhl = ord(self.raw_data[tmp_parse_pos])
tmp_parse_pos += 1
if len(self.raw_data[tmp_parse_pos:]) < tmp_parse_pos + tmp_udhl:
return
while tmp_parse_pos < tmp_parse_pos + tmp_udhl:
iei = ord(self.raw_data[tmp_parse_pos])
tmp_parse_pos += 1
ieidl = ord(self.raw_data[tmp_parse_pos])
tmp_parse_pos += 1
ied = self.raw_data[tmp_parse_pos:tmp_parse_pos+ieidl]
tmp_parse_pos += ieidl
if iei == 0x05:
#print 'application port address 16 bit'
#assert ieidl == 4
dest_port, orig_port = ord(ied[0]) * 256 + ord(ied[1]), ord(ied[2]) * 256 + ord(ied[3])
#print 'dest port', dest_port, 'orig_port', orig_port
#self.handle_app_port16(dest_port)
if (2948 == dest_port and 9200 == orig_port):
self.bMMSNoti = MMSNOTIFICATION_IND
#print 'destport,origport', MMSNOTIFICATION_IND
if MMSNOTIFICATION_IND == self.bMMSNoti:
#print 'MMS_DELIVERY.no_udhi --', tmp_parse_pos, self.parse_pos
self.parse_pos = tmp_parse_pos
def parse_user_data(self):
import smartmsg
self.udl = self.get_byte()
#print 'user data len', self.udl
if config.sms_debug:
import utils
utils.print_hex(self.raw_data[self.parse_pos:])
remaining_len = len(self.raw_data) - self.parse_pos
# self.udhi = True # 강제로 User Data Header가 있는 것처럼
if self.udhi:
self.parse_user_data_header()
#if not self.udhi:
# self.check_MMS_delivery()
user_data = self.raw_data[self.parse_pos:]
self.IsMMSnotification()
if MMSDELIVERY_IND == self.bMMSNoti:
from mms_net_pdu import Parse_MMSDeliveryReport
to = ''
status = ''
to, status = Parse_MMSDeliveryReport(user_data)
if None == to and None == status:
return
idx = to.find('/TYPE=')
if -1 != idx:
to = to[:idx]
deliverymsg = MMSDELIVERY_MSG % (to, status)
from setting import setting
if setting.mms_enable:
self.bMMSNoti = SMSMESSASGE
self.contents.append(('Text', deliverymsg))
return
#if not user_data:
# print 'user data is empty'
if self.encoding == ENCODING_7:
if not ((remaining_len - 1) * 8 < self.udl * 7 <= (remaining_len * 8)):
#print 'bad udl', self.udl,remaining_len
self.bad_udl = True
return
if self.udhl:
fill = 7 - (self.udhl + 1) * 8 % 7
if fill == 7: fill = 0
else:
fill = 0
if self.udhl:
text_len = (self.udl * 7 - (self.udhl + 1) * 8 - fill)/7
else:
text_len = self.udl
message = gsm7.gsm7_unpack(user_data, fill, text_len)
self.contents.append(('Text', message))
elif self.encoding == ENCODING_8:
if self.udl != remaining_len:
self.bad_udl = True
return
if self.message_total_number != 1:
self.contents.append(smartmsg.RawData(self.content_type, user_data))
return
if self.content_type == 'Multipart':
multi_part = smartmsg.Multipart(user_data)
self.contents += multi_part.contents
else:
if self.bMMSNoti:
#print 'mms.noti.1sms', self.bMMSNoti
self.contents.append(smartmsg.RawData(self.content_type, user_data))
return
if self.content_type == 'Text':
user_data = unicode(user_data, 'iso8859-1').encode('utf8')
self.contents.append(smartmsg.parse_content(self.content_type, user_data))
elif self.encoding == ENCODING_UCS2:
if self.udl != remaining_len:
self.bad_udl = True
return
#print 'FIXME: ucs 2 encoding used'
user_data = unicode(user_data, 'UTF16')
self.contents.append((self.content_type, user_data.encode('utf8')))
def arrange_ems(self):
if config.sms_debug:
print 'arrange_ems', self.ems_contents, self.contents
if not self.ems_contents:
return
if not self.contents:
self.contents = self.ems_contents
return
if len(self.contents) > 1 or self.contents[0][0] != 'Text':
#print 'FIXME:arrage_ems: self.contents', self.contents
#print 'FIXME:arrage_ems: ems_contents', self.ems_contents
return
pos = 0
txt = self.contents[0][1]
contents = []
for ie in self.ems_contents:
#print 'arrage_ems: ie', ie.type
#print 'arrage_ems: pos =', pos, 'ie pos', ie.pos
if ie.pos > pos:
contents.append(('Text', txt[pos:ie.pos]))
pos = ie.pos
contents.append((ie.type, ie))
if len(txt) > pos:
contents.append(('Text', txt[pos:]))
self.contents = contents
def parse_ied(self):
iei = self.get_byte()
ieidl = self.get_byte()
ied = self.get_data(ieidl)
#print 'parse_ied: iei = %02X, ieidl = %d' % (iei, ieidl)
if iei == 0x00:
self.message_ref = ord(ied[0])
self.message_total_number = ord(ied[1])
self.message_seq = ord(ied[2])
#print 'concaternated short message: 8 bit', self.message_ref, self.message_total_number, self.message_seq
#if self.message_seq == 0:
# print 'WARNING: invalid sms ref: 0', 'Will be discarded'
#if self.message_seq == 0:
# self.message_seq = 2
elif iei == 0x04:
#print 'application port address 8 bit'
#assert ieidl == 2
dest_port, orig_port = ord(ied[0]), ord(ied[1])
#print 'dest port', dest_port, 'orig_port', orig_port
elif iei == 0x05:
#print 'application port address 16 bit'
#assert ieidl == 4
dest_port, orig_port = ord(ied[0]) * 256 + ord(ied[1]), ord(ied[2]) * 256 + ord(ied[3])
#print 'dest port', dest_port, 'orig_port', orig_port
self.handle_app_port16(dest_port)
if (2948 == dest_port and 9200 == orig_port):
self.bMMSNoti = MMSNOTIFICATION_IND
#print 'destport,origport', MMSNOTIFICATION_IND
elif iei == 0x08:
#print 'concaternated short message: 16 bit'
self.message_ref = ord(ied[0]) * 256 + ord(ied[1])
self.message_total_number = ord(ied[2])
self.message_seq = ord(ied[3])
elif iei == 0x0a:
self.parse_ems_text_format(ied);
#print 'FIXME: EMS text formating'
elif iei == 0x0b:
#assert len(ied) == 2
self.ems_contents.append(ems.PredefinedSound(ied))
#print 'EMS: predefined sound'
elif iei == 0x0c:
self.ems_contents.append(ems.UserDefinedSound(ied))
#print 'EMS: user defined sound' # iMelody max 128
elif iei == 0x0d:
self.ems_contents.append(ems.PredefinedAnimation(ied))
#print 'EMS: predefined animation'
elif iei == 0x0e:
self.ems_contents.append(ems.LargeAnimation(ied))
#print 'EMS: large animation' # 16 * 16 * 4 max 128
elif iei == 0x0f:
self.ems_contents.append(ems.SmallAnimation(ied))
#print 'EMS: small animation' # 8 * 8 * 4 max 32
elif iei == 0x10:
self.ems_contents.append(ems.LargePicture(ied))
#print 'EMS: large picture' # 32 * 32 = 128
elif iei == 0x11:
self.ems_contents.append(ems.SmallPicture(ied))
#print 'EMS: small picture' # 16 * 16 = 32
elif iei == 0x12:
self.ems_contents.append(ems.VariablePicture(ied))
#print 'EMS: variable picture'
elif iei == 0x14:
pass
#print 'FIXME:::: !!!!!!EMS: extended object'
elif iei == 0x15:
pass
#print 'reused extended object'
else:
pass
#print 'FIXME: ************unhandled IED', iei
def parse_ems_text_format(self, ied):
ie_parser = Parser(ied)
#assert len(ied) == 4
pos = ie_parser.get_byte()
formatting_len = ie_parser.get_byte()
formatting_mode = ie_parser.get_byte()
color = ie_parser.get_byte()
def handle_app_port16(self, port):
if port == 0x1582:
self.content_type = 'Operator Logo'
#print 'Operator Logo'
elif port == 0x1581:
self.content_type = 'Ring'
#print 'Ring data'
elif port == 0x1583:
self.content_type = 'CLI Icon'
#print 'CLI Icon'
elif port == 0x158A:
self.content_type = 'Multipart'
#print 'Multipart'
elif port == 0x23F5:
self.content_type = 'vCalendar'
#print 'vCalendar'
elif port == 0x23F4:
self.content_type = 'vCard'
#print 'vCalendar'
else:
pass
#print 'Unhandled App Pport %04X' % port
class StatusReport(Deliver):
def __init__(self, message):
Parser.__init__(self, message)
self.compress = False
self.contents = []
self.ems_contents = []
self.content_type = 'Text'
self.message_ref = 0
self.message_total_number = 1
self.message_seq = 1
self.bad_udl = False
self.udhl = 0
self.has_udl = False
self.bMMSNoti = SMSMESSASGE
self.parse_header()
if self.has_udl:
self.parse_user_data()
else:
if config.sms_debug:
print 'status report: no user data'
def parse_header(self):
flags = self.get_byte()
self.mti = (flags >> MTI_SHIFT) & MTI_MASK
self.mms = (flags >> MMS_SHIFT) & MMS_MASK
self.udhi = (flags >> UDHI_SHIFT) & UDHI_MASK
#if self.udhi:
# print 'has user data header'
self.ref = self.get_byte()
self.parse_addr()
#print self.addr
self.parse_scts()
if config.sms_debug:
print 'status report: scts', self.scts
self.parse_dt()
if config.sms_debug:
print 'status report: dt', self.dt
self.parse_status()
if config.sms_debug:
print 'status report: total size', len(self.raw_data), 'current pos =', self.parse_pos
if len(self.raw_data) <= self.parse_pos:
return
self.pi = self.get_byte()
if self.pi & 1:
self.pid = self.get_byte()
if self.pi & 2:
self.parse_dcs()
else:
self.encoding = ENCODING_7
if self.pi & 4:
self.has_udl = True
def parse_dt(self):
self.dt = decode_scts(self.get_data(7))
def parse_status(self):
self.status = self.get_byte()
if config.sms_debug:
print 'sms status: status =', self.status
# 0: received
# 1: can't confirm
# 2: replaced
# 32: congestion
# 32 + 1: sme busy
# 32 + 2: no response from SME
# 32 + 3: service rejected
# 32 + 4: qos not available
# 32 + 5: error in SME
#
class SmsMessage:
def __init__(self, *va):
self.type = ''
self.number = ''
self.contents = []
self.protocol_id = ''
if va:
self._set(*va)
self.filename = None
self.time = None
self.read = False
self.sent = False
self.bMMSNoti = SMSMESSASGE
def _set(self, number = '', protocol_id = '', contents = []):
self.type = 'submit'
self.number = number
self.protocol_id = protocol_id
self.contents = contents
def set_from_submit(self, submit):
self._set(submit.number, submit.protocol_id, submit.contents)
def get_submit(self, **kw):
return Submit(self.protocol_id, self.number, self.contents, **kw)
def send(self, **kw):
#print 'sms send', self.contents
submit = self.get_submit(**kw)
try:
runtime.modem.sms_send(submit.segments)
except utils.InterruptException:
runtime.manager.queue_interrupt()
raise
import time, ntptime
y, m1, d, h, m2, s = time.localtime(ntptime.ntime())[:6]
self.time = (y-2000, m1, d, h, m2, s, 0)
def set_from_deliver(self, deliver):
self.type = 'deliver'
self.number = deliver.addr
self.time = deliver.scts
self.contents = deliver.contents
if (deliver.bMMSNoti):
self.bMMSNoti = MMSNOTIFICATION_IND
def set_from_status_report(self, sr):
self.type = 'status report'
self.number = sr.addr
self.time = sr.scts
self.contents = sr.contents
def summary(self, count):
s = ''
for t, c in self.contents:
if t == 'Text':
s += c
return (unicode(s, 'utf-8')[:count]).encode('utf-8')
def get_pictures(self):
ret = []
for type, c in self.contents:
if type in ('Bitmap',):
ret.append(c)
return ret
def get_predefined_melodies(self):
ret = []
for type, c in self.contents:
if type == 'Melody':
if c.predefined:
ret.append(c)
return ret
def get_melodies(self):
ret = []
for type, c in self.contents:
if type in ('Melody',):
ret.append(c)
return ret
def load(self, filename):
self.filename = filename
fp = open(filename)
self.type = fp.readline().strip()
self.number = fp.readline().strip()
self.protocol_id = fp.readline().strip()
time_str = fp.readline().strip()
if time_str:
self.time = [int(x) for x in time_str.split()]
else:
self.time = None
if self.type == 'submit':
self.sent = False
if fp.readline().strip() == '1':
self.sent = True
else:
self.read = False
if fp.readline().strip() == '1':
self.read = True
self.contents = []
while True:
data_type = fp.readline().strip()
#print data_type
if not data_type:
break
c1, c2 = fp.read(2)
data_len = ord(c1) * 256 + ord(c2)
#print 'data len', data_len
data = fp.read(data_len)
### content loader
self.contents.append(ems.load_data(data_type, data))
def MMSload(self, filename, text):
self.filename = filename
self.contents = []
if self.filename:
fp = open(filename)
text = fp.read()
# text = unicode(text, 'utf-8')
text = text.strip()
self.contents.append(('Text', text))
def save(self, filename = None):
if not filename:
#assert self.filename
filename = self.filename
fp = open(filename, 'w')
fp.write(self.type + '\n')
fp.write(self.number + '\n')
fp.write(self.protocol_id + '\n')
if self.time:
fp.write('%d %d %d %d %d %d %d' % tuple(self.time) + '\n')
else:
#fp.write('\n')
import time, ntptime
y, m1, d, h, m2, s = time.localtime(ntptime.ntime())[:6]
self.time = (y-2000, m1, d, h, m2, s, 0)
fp.write('%d %d %d %d %d %d %d' % tuple(self.time) + '\n')
if self.type == 'submit':
fp.write('%d' % self.sent + '\n')
else:
fp.write('%d' % self.read + '\n')
for type, content in self.contents:
fp.write(type + '\n')
if type != 'Text':
content = content.get_raw_data()
content_len = len(content)
c1, c2 = divmod(content_len, 256)
fp.write(chr(c1) + chr(c2))
fp.write(content)
class MmsHeaderHandler:
def __init__(self):
self.toName = ''
self.toDomain = ''
# MMS Header
self.mmsMessageType = ''
self.messageType = ''
self.messageCallback = ''
self.mmsExplicitNo = ''
self.transactionID = ''
self.mmsVersion = MMS_VERSION_VALUE
self.mmsIP = ''
self.mmsDate = ''
self.mmsFrom = ''
self.mmsTo = ''
self.mmsSubject = ''
self.mmsMessageClass = PERSONAL_CLASS
self.deliveryTime = ''
self.mmsPriority = Priority_Normal
self.mmsSenderVisibility = Visibility_Show
self.mmsDeliveryReport = True
self.mmsReadReply = False
self.store = False
self.mmsContentType = ''
self.mmsMessageID = ''
self.mmsTransactionID = ''
self.mmsResponseStatus = ''
self.mmsResponseStatusText = ''
self.mmsStatus = ''
self.header = []
def printVar(self, number):
print '>>>> MmsHeaderHandler ====> ', number
print 'self.mmsMessageType = ', self.mmsMessageType
print 'self.messageType = ', self.messageType
print 'self.messageCallback = ', self.messageCallback
print 'self.mmsExplicitNo = ', self.mmsExplicitNo
print 'self.transactionID = ', self.transactionID
print 'self.mmsVersion = ', self.mmsVersion
print 'self.mmsIP = ', self.mmsIP
print 'self.mmsDate = ', self.mmsDate
print 'self.mmsFrom = ', self.mmsFrom
print 'self.mmsTo = ', self.mmsTo
print 'self.mmsSubject = ', self.mmsSubject
print 'self.mmsMessageClass = ', self.mmsMessageClass
print 'self.deliveryTime = ', self.deliveryTime
print 'self.mmsPriority = ', self.mmsPriority
print 'self.mmsSenderVisibility = ', self.mmsSenderVisibility
print 'self.mmsDeliveryReport = ', self.mmsDeliveryReport
print 'self.mmsReadReply = ', self.mmsReadReply
print 'self.store = ', self.store
print 'self.mmsContentType = ', self.mmsContentType
print 'self.mmsMessageID = ', self.mmsMessageID
print 'self.mmsTransactionID = ', self.mmsTransactionID
print 'self.mmsResponseStatus = ', self.mmsResponseStatus
print 'self.mmsResponseStatusText = ', self.mmsResponseStatusText
print 'self.mmsStatus = ', self.mmsStatus
print 'end -------------------------'
def getToName(self):
return self.toName
def setToName(self, toName):
self.toName = toName
def getToDomain(self):
return self.toDomain
def setToDomain(self, toDomain):
self.toDomain = toDomain
# MMS Header
def getMmsMessageType(self):
return self.mmsMessageType
def setMmsMessageType(self, mmsMessageType):
self.mmsMessageType = mmsMessageType
def getMessageType(self):
return self.messageType
def setMessageType(self, messageType):
self.messageType = messageType
def getMessageCallback(self):
return self.messageCallback
def setMessageCallback(self, messageCallback):
self.messageCallback = messageCallback
def getMmsExplicitNo(self):
return self.mmsExplicitNo
def setMmsExplicitNo(self, mmsExplicitNo):
self.mmsExplicitNo = mmsExplicitNo
def getTransactionID(self):
return self.transactionID
def setTransactionID(self, transactionID):
self.transactionID = transactionID
def getMmsVersion(self):
return self.mmsVersion
def setMmsVersion(self, mmsVersion):
self.mmsVersion = mmsVersion
def getMmsIP(self):
return self.mmsIP
def setMmsIP(self, mmsIP):
self.mmsIP = mmsIP
def getMmsDate(self):
return self.mmsDate
def setMmsDate(self, mmsDate):
self.mmsDate = mmsDate
def getMmsFrom(self):
return self.mmsFrom
def setMmsFrom(self, mmsFrom):
self.mmsFrom = mmsFrom
def getMmsTo(self):
return self.mmsTo
def makeMmsTo(self):
return 'sip:' + self.toName[:3] +'_' + self.toName[3:6] + '_' + self.toName[6:10]+ '@' + self.toDomain
def setMmsTo(self, mmsTo):
self.mmsTo = mmsTo
def getMmsSubject(self):
return self.mmsSubject
def setMmsSubject(self, mmsSubject):
self.mmsSubject = mmsSubject
def getMmsMessageClass(self):
return self.mmsMessageClass
def setMmsMessageClass(self, mmsMessageClass):
self.mmsMessageClass = mmsMessageClass
def getDeliveryTime(self):
return self.deliveryTime
def makeTimeStamp(self):
import time
now = time.localtime()
now = now[:6]
now = '%04d%02d%02d%02d%02d%02d' % now
return now
def setDeliveryTime(self, deliveryTime):
self.deliveryTime = deliveryTime
def getMmsPriority(self):
return self.mmsPriority
def setMmsPriority(self, mmsPriority):
self.mmsPriority = mmsPriority
def getMmsSenderVisibility(self):
return self.mmsSenderVisibility
def setMmsSenderVisibility(self, mmsSenderVisibility):
self.mmsSenderVisibility = mmsSenderVisibility
def getMmsDeliveryReport(self):
return self.mmsDeliveryReport
def setMmsDeliveryReport(self, mmsDeliveryReport):
self.mmsDeliveryReport = mmsDeliveryReport
def getMmsReadReply(self):
return self.mmsReadReply
def setMmsReadReply(self, mmsReadReply):
self.mmsReadReply = mmsReadReply
def getStore(self):
return self.store
def setStore(self, store):
self.store = store
def getMmsContentType(self):
return self.mmsContentType
def setMmsContentType(self, mmsContentType):
self.mmsContentType = mmsContentType
# conf
def getMmsMessageID(self):
return self.mmsMessageID
def setMmsMessageID(self, mmsMessageID):
self.mmsMessageID = mmsMessageID
def getMmsTransactionID(self):
return self.mmsTransactionID
def setMmsTransactionID(self, mmsTransactionID):
self.mmsTransactionID = mmsTransactionID
def getMmsResponseStatus(self):
return self.mmsResponseStatus
def setMmsResponseStatus(self, mmsResponseStatus):
self.mmsResponseStatus = mmsResponseStatus
def getMmsStatus(self):
return self.mmsResponseStatus
def setMmsStatus(self, mmsStatus):
self.mmsStatus = mmsStatus
def getMmsResponseStatusText(self):
return self.mmsResponseStatusText
def setMmsResponseStatusText(self, mmsResponseStatusText):
self.mmsResponseStatusText = mmsResponseStatusText
def makeHeader(self, headerList):
for headerName in headerList:
if headerName == X_Mms_Message_Type:
self.header.append(X_Mms_Message_Type + ': ' + self.mmsMessageType + CRLF)
elif headerName == X_Message_Type:
self.header.append(X_Message_Type + ': ' + self.messageType + CRLF)
elif headerName == X_Mms_Message_ID:
self.header.append(X_Mms_Message_ID + ': ' + self.mmsMessageID + CRLF)
elif headerName == X_Message_Callback:
if self.messageCallback:
self.header.append(X_Message_Callback + ': ' + self.messageCallback + CRLF)
elif headerName == X_Mms_Explicit_No:
if self.mmsExplicitNo:
self.header.append(X_Mms_Explicit_No + ': ' + self.mmsExplicitNo + CRLF)
elif headerName == X_Mms_Transaction_ID:
self.transactionID = self.toName + self.toDomain + Get_CurrentDate()
self.header.append(X_Mms_Transaction_ID + ': ' + self.transactionID + CRLF)
elif headerName == X_Mms_MMS_Version:
self.header.append(X_Mms_MMS_Version + ': ' + self.mmsVersion + CRLF)
elif headerName == X_Mms_IP:
import phonesetting
self.mmsIP = phonesetting.cur_profile.ipaddress
self.header.append(X_Mms_IP + ': ' + self.mmsIP + CRLF)
elif headerName == From:
from vdcisetting import vdci_setting
self.mmsFrom = 'sip:' + vdci_setting.tel_num + '@' + vdci_setting.domain
self.header.append(From + ': ' + self.mmsFrom + CRLF)
elif headerName == To:
self.header.append(To + ': ' + self.mmsTo + CRLF)
elif headerName == Subject:
self.header.append(Subject + ': ' + self.mmsSubject + CRLF)
elif headerName == X_Mms_Message_Class:
self.header.append(X_Mms_Message_Class + ': ' + self.mmsMessageClass + CRLF)
elif headerName == X_Mms_Delivery_Time:
if self.deliveryTime:
self.header.append(X_Mms_Delivery_Time + ': ' + self.deliveryTime + CRLF) #YYYYMMDDhhmmss
elif headerName == X_Mms_Priority:
self.header.append(X_Mms_Priority + ': ' + self.mmsPriority + CRLF)
elif headerName == X_Mms_Sender_Visibility:
self.header.append(X_Mms_Sender_Visibility + ': ' + self.mmsSenderVisibility + CRLF)
elif headerName == X_Mms_Delivery_Report:
if self.mmsDeliveryReport:
self.header.append(X_Mms_Delivery_Report + ': ' + YES + CRLF)
else:
self.header.append(X_Mms_Delivery_Report + ': ' + NO + CRLF)
elif headerName == X_Mms_Read_Reply:
if self.mmsReadReply:
self.header.append(X_Mms_Read_Reply + ': ' + YES + CRLF)
else:
self.header.append(X_Mms_Read_Reply + ': ' + NO + CRLF)
elif headerName == X_Mms_Store:
if self.store:
self.header.append(X_Mms_Store + ': ' + YES + CRLF)
else:
self.header.append(X_Mms_Store + ': ' + NO + CRLF)
elif headerName == Content_Type:
self.header.append(Content_Type + ': ' + self.mmsContentType + CRLF) #Content-Type
elif headerName == X_Mms_Staus:
self.header.append(X_Mms_Staus + ': ' + self.mmsStatus + CRLF)
if config.mms_debug:
print '== [HEADER] : MM1_Submit_Request_SMS ==============='
print self.header
print '==========================================='
return ''.join(self.header)
# hcryoo : [20071217_1] : KT ISMC 지원
class IsmcContentHandler:
def __init__(self):
self.contents = []
self.supported = True
# MMS Body
def getContents(self):
return self.contents
def setContents(self, contents):
self.contents = contents
def appendContent(self, content):
self.contents.append(content)
def setSupported(self, supported):
self.supported = supported
def getSupported(self):
return self.supported
def cutTwoByteInBody(self):
index = 0
for i, content in enumerate(self.contents):
if type == 'Text':
index = i
cuttedString = self.contents[index][1][:-2]
del(self.contents[index])
self.contents.insert(index, ('Text', cuttedString))
def makeMessage(self):
message = []
for type, content in self.contents:
if type == 'Text':
content = unicode(content, 'utf-8').encode('euc-kr')
message.append(content)
continue
return ''.join(message)
# hcryoo : [20071217_1] : KT ISMC 지원==
'''
class MmsBodyHandler:
def __init__(self):
self.contents = []
self.supported = True
# MMS Body
def getContents(self):
return self.contents
def setContents(self, contents):
self.contents = contents
def appendContent(self, content):
self.contents.append(content)
def setSupported(self, supported):
self.supported = supported
def getSupported(self):
return self.supported
def cutTwoByteInBody(self):
index = 0
for i, content in enumerate(self.contents):
if type == 'Text':
index = i
cuttedString = self.contents[index][1][:-2]
del(self.contents[index])
self.contents.insert(index, ('Text', cuttedString))
def makeBody(self):
body = []
for type, content in self.contents:
if type == 'Text':
content = unicode(content, 'utf-8').encode('euc-kr')
body.append(content)
continue
return ''.join(body)
'''
# hcryoo : [20071217_1] : KT ISMC 지원
class IsmcMessageHandler:
def __init__(self, contentH=None):
if not contentH:
self.ismcContentHandler = IsmcContentHandler()
else:
self.ismcContentHandler = contentH
self.messageString = ''
self.filePath = ''
self.ismcSubject = ''
self.deliveryTime = ''
def getIsmcSubject(self):
return self.ismcSubject
def setIsmcSubject(self, ismcSubject):
self.ismcSubject = ismcSubject
def getDeliveryTime(self):
return self.deliveryTime
def setDeliveryTime(self, deliveryTime):
self.deliveryTime = deliveryTime
def makeTimeStamp(self):
import time
now = time.localtime()
now = now[:6]
now = '%04d%02d%02d%02d%02d%02d' % now
return now
def getMessageString(self):
return self.messageString
def setMessageString(self, messageString):
self.messageString = messageString
def getIsmcContentHandler(self):
return self.ismcContentHandler
def setIsmcContentHandler(self, ismcContentHandler):
self.ismcContentHandler = ismcContentHandler
def makeIsmcBody(self, makeSubject=False):
if self.ismcContentHandler.getSupported():
self.messageString = self.ismcContentHandler.makeMessage()
else:
self.messageString = ''
if makeSubject and self.messageString:
self.ismcSubject = unicode(self.messageString, 'euc-kr')[:12].encode('utf-8')
pass
msgsize = len(self.messageString)+1 / 1024
if not utils.check_free_storage('mms_save', msgsize):
from basemodel import StorageFullError
raise StorageFullError
return
self.filePath = mmsconfig.mms_temp_message + Get_CurrentDate()
fileHandle = open(self.filePath, 'wb+')
if self.ismcContentHandler.getSupported():
#fileHandle.write(CRLF)
fileHandle.write(self.messageString)
fileHandle.close()
return self.filePath
def parse(self, filename):
if filename:
fileHandle = open(filename)
else:
print 'ERROR MESSAGE PARSE'
return
for line in fileHandle:
if self.ismcContentHandler.getSupported():
self.ismcContentHandler.appendContent(('Text', line))
fileHandle.close()
# hcryoo : [20071217_1] : KT ISMC 지원==
'''
class MmsMessageHandler:
def __init__(self, headerH=None, bodyH=None):
if not headerH:
self.mmsHeaderHandler = MmsHeaderHandler()
else:
self.mmsHeaderHandler = headerH
if not bodyH:
self.mmsBodyHandler = MmsBodyHandler()
else:
self.mmsBodyHandler = bodyH
self.headerString = ''
self.bodyString = ''
self.filePath = ''
def getMmsHeaderHandler(self):
return self.mmsHeaderHandler
def setMmsHeaderHandler(self, mmsHeaderHandler):
self.mmsHeaderHandler = mmsHeaderHandler
def getMmsBodyHandler(self):
return self.mmsBodyHandler
def setMmsBodyHandler(self, mmsBodyHandler):
self.mmsBodyHandler = mmsBodyHandler
def getHeaderString(self):
return self.headerString
def setHeaderString(self, headerString):
self.headerString = headerString
def makeMmsMessage(self, headerList):
self.headerString = self.mmsHeaderHandler.makeHeader(headerList)
if self.mmsBodyHandler.getSupported():
self.bodyString = self.mmsBodyHandler.makeBody()
else:
self.bodyString = ''
msgsize = (len(self.headerString)+len(self.bodyString)+1) / 1024
if not utils.check_free_storage('mms_save', msgsize):
from basemodel import StorageFullError
raise StorageFullError
return
self.filePath = mmsconfig.mms_temp_message + Get_CurrentDate()
fileHandle = open(self.filePath, 'wb+')
fileHandle.write(self.headerString)
if self.mmsBodyHandler.getSupported():
fileHandle.write(CRLF)
fileHandle.write(self.bodyString)
fileHandle.close()
return self.filePath
def removeCRLF(self, headerValue):
if headerValue:
headerValue = headerValue.replace('\n', '')
headerValue = headerValue.replace('\r', '')
else:
headerValue = ''
return headerValue
def parse(self, filename):
if filename:
fileHandle = open(filename)
else:
print 'ERROR MESSAGE PARSE'
return
isHeader = True
for line in fileHandle:
if isHeader:
headerName = line[:line.find(':')]
headerValue = self.removeCRLF(line[line.find(':')+2:])
if headerName == mms_net_define.X_Mms_Message_Type:
self.mmsHeaderHandler.setMmsMessageType(headerValue)
elif headerName == mms_net_define.X_Mms_Message_ID:
self.mmsHeaderHandler.setMmsMessageID(headerValue)
elif headerName == mms_net_define.Date:
self.mmsHeaderHandler.setMmsDate(headerValue)
elif headerName == mms_net_define.To:
self.mmsHeaderHandler.setMmsTo(headerValue)
elif headerName == mms_net_define.X_Message_Type:
self.mmsHeaderHandler.setMessageType(headerValue)
elif headerName == mms_net_define.X_Message_Callback:
self.mmsHeaderHandler.setMessageCallback(headerValue)
elif headerName == mms_net_define.X_Mms_Explicit_No:
self.mmsHeaderHandler.setMmsExplicitNo(headerValue)
elif headerName == mms_net_define.From:
self.mmsHeaderHandler.setMmsFrom(headerValue)
elif headerName == mms_net_define.Subject:
self.mmsHeaderHandler.setMmsSubject(headerValue)
elif headerName == mms_net_define.X_Mms_Message_Class:
self.mmsHeaderHandler.setMmsMessageClass(headerValue)
elif headerName == mms_net_define.X_Mms_Priority:
self.mmsHeaderHandler.setMmsPriority(headerValue)
elif headerName == mms_net_define.X_Mms_Sender_Visibility:
self.mmsHeaderHandler.setMmsSenderVisibility(headerValue)
elif headerName == mms_net_define.X_Mms_Delivery_Report:
self.mmsHeaderHandler.setMmsDeliveryReport(headerValue)
elif headerName == mms_net_define.Content_Type:
self.mmsHeaderHandler.setMmsContentType(headerValue)
elif headerName == mms_net_define.Message_ID:
self.mmsHeaderHandler.setMmsMessageID(headerValue)
elif headerName == mms_net_define.X_Mms_Transaction_ID:
self.mmsHeaderHandler.setMmsTransactionID(headerValue)
elif headerName == mms_net_define.X_Mms_Response_Status:
self.mmsHeaderHandler.setMmsResponseStatus(headerValue)
elif headerName == mms_net_define.X_Mms_Response_Status_Text:
self.mmsHeaderHandler.setMmsResponseStatusText(headerValue)
elif headerName == mms_net_define.X_Mms_Status:
self.mmsHeaderHandler.setMmsStatus(headerValue)
else:
if line == CRLF:
isHeader = False
else:
if self.mmsBodyHandler.getSupported():
self.mmsBodyHandler.contents.append(('Text', line))
fileHandle.close()
'''
class SmsMessage_KT:
def __init__(self):
self.smsInfoHandler = SmsInfoHandler()
self.smsSipHandler = SmsSipHandler()
self.ismcMessageHanler = IsmcMessageHandler()
def getSmsInfoHandler(self):
return self.smsInfoHandler
def setSmsInfoHandler(self, smsInfoHandler):
self.smsInfoHandler = smsInfoHandler
def getSmsSipHandler(self):
return self.smsSipHandler
def setSmsSipHandler(self, smsSipHandler):
self.smsSipHandler = smsSipHandler
def getIsmcMessageHandler(self):
return self.ismcMessageHandler
def setIsmcMessageHandler(self, ismcMessageHandler):
self.ismcMessageHandler = ismcMessageHandler
def save(self, filename = None):
if not filename:
print 'ERROR in SAVE'
return
import os
os.rename(self.smsSipHandler.getSipAbsMessagePath(), filename)
self.smsSipHandler.setSipAbsMessagePath(filename)
def load(self, filename):
self.filename = filename
fp = open(filename)
self.type = fp.readline().strip()
self.number = fp.readline().strip()
self.protocol_id = fp.readline().strip()
time_str = fp.readline().strip()
if time_str:
self.time = [int(x) for x in time_str.split()]
else:
self.time = None
if self.type == 'submit':
self.sent = False
if fp.readline().strip() == '1':
self.sent = True
else:
self.read = False
if fp.readline().strip() == '1':
self.read = True
self.contents = []
while True:
data_type = fp.readline().strip()
#print data_type
if not data_type:
break
c1, c2 = fp.read(2)
data_len = ord(c1) * 256 + ord(c2)
#print 'data len', data_len
data = fp.read(data_len)
### content loader
self.contents.append(ems.load_data(data_type, data))
def submit_test():
status.message_reference = 8
submit = Submit('email', '4210', 'abcdefg')
m = str(submit)
#print 'message len', len(m)
#for x in m:
# print "[%02X]" % ord(x)
def save_test():
message = SmsMessage()
message.load('00000001')
#print message.contents
def deliver_test():
mms_deli = "\x91\x7F\x44\x09\x81\x09\x70\x61\x08\xF0\x00\x04\x50\x21\x70\x22\
\x21\x00\x40\x6D\x06\x05\x04\x0B\x84\x23\xF0\x04\x06\x37\x61\x70\
\x70\x6C\x69\x63\x61\x74\x69\x6F\x6E\x2F\x76\x6E\x64\x2E\x77\x61\
\x70\x2E\x6D\x6D\x73\x2D\x6D\x65\x73\x73\x61\x67\x65\x00\x45\x6E\
\x63\x6F\x64\x69\x6E\x67\x2D\x76\x65\x72\x73\x69\x6F\x6E\x00\x31\
\x2E\x31\x00\xAF\x84\x8C\x86\x8D\x91\x8B\x32\x30\x30\x35\x31\x32\
\x30\x37\x32\x32\x31\x30\x32\x34\x34\x35\x39\x36\x35\x00\x97\x39\
\x31\x33\x32\x36\x30\x37\x37\x36\x00\x85\x04\x43\x97\x50\x20\x95\
\x85\xBD"
segment1 = "\x91\x9E\x40\x0A\x81\x21\x43\x65\x87\x09\x00\x00\x30\x11\x72\x01\x03\x32\x40\xA0\x05\x00\x03\x99\x02\x01\xA0\xF2\x74\xFB\x0D\x22\xA7\x41\xE4\x7A\x19\xD4\x2E\xCF\xE7\xE1\xF3\x39\x0D\x1A\xBF\xDD\xE3\x30\xBD\xEC\x0E\xD3\xD3\x20\xB8\x3C\xDD\x7E\x83\xC8\x69\x10\xB9\x5E\x06\xB5\xCB\xF3\x79\xF8\x7C\x4E\x83\xC6\x6F\xF7\x38\x4C\x2F\xBB\xC3\xF4\x34\x08\x2E\x4F\xB7\xDF\x20\x72\x1A\x44\xAE\x97\x41\xED\xF2\x7C\x1E\x3E\x9F\xD3\xA0\xF1\xDB\x3D\x0E\xD3\xCB\xEE\x30\x3D\x0D\x82\xCB\xD3\xED\x37\x88\x9C\x06\x91\xEB\x65\x50\xBB\x3C\x9F\x87\xCF\xE7\x34\x68\xFC\x76\x8F\xC3\xF4\xB2\x3B\x4C\x4F\x83\xCC\x69\x77\x19\xD4\x2E\xCF\xE7\xE1\xF3\x39\xFD\x06\xC5\x5C\xBD"
segment2 = "\x91\x66\x44\x0A\x81\x21\x43\x65\x87\x09\x00\x00\x30\x11\x72\x01\x03\x32\x40\x60\x05\x00\x03\x99\x02\x02\xA6\xE5\xF1\xDB\x4D\x7E\x83\xC8\x69\x10\xB9\x5E\x06\xB5\xCB\xF3\x79\xF8\x7C\x4E\x83\xC6\x6F\xF7\x38\x4C\x2F\xBB\xC3\xF4\x34\x68\x5E\x1E\xBF\xDD\xE4\x37\x88\x9C\x06\x91\xEB\x65\x50\xBB\x3C\x9F\x87\xCF\xE7\x34\x68\xFC\x76\x8F\xC3\xF4\xB2\x3B\x4C\x4F\x83\xCC\x69\x77\x19\xD4\x2E\xCF\xE7\xE1\xF3\x39\xFD\x06\xC9\x5C\x20"
deliver1 = Deliver(segment1[2:-1])
deliver2 = Deliver(segment2[2:-1])
#print 'deliver1', deliver1.contents
#print 'deliver2', deliver2.contents
import sms
sms.sms_queue.add((deliver1,))
messages = sms.sms_queue.get_message()
#import smsmanager
#for m in messages:
# smsmanager.smsmgr.insert_msg(m)
sms.sms_queue.add((deliver2,))
messages = sms.sms_queue.get_message()
#for m in messages:
# print 'message contents', m.contents
def status_report_test():
message = "\x22\x01\x0B\x91\x80\x00\x11\x50\x76\xF8\x50\x10\x40\x00\x31" + \
"\x03\x00\x50\x10\x40\x00\x31\x03\x00\x00\x04\x35\xF9\x77\x5D\x0E" + \
"\x6A\x97\xE7\xF3\xF0\xB9\x0C\xBA\x87\xE7\xA0\xF1\x5B\x2E\x2F\x8F" + \
"\xE9\xEC\x3C\x88\x5C\x66\xA7\xED\x65\x79\x99\x0C\x0A\xD3\x41\x74" + \
"\x74\x19\x24\x2F\x8F\xD3\xF0\x74\xD9\x4D\x07"
sr = StatusReport(message)
#print sr.contents
if __name__ == '__main__':
#save_test()
#deliver_test()
status_report_test()
