| /**************************************************************************** |
| ** |
| ** This file is part of the Qt Extended Opensource Package. |
| ** |
| ** Copyright (C) 2009 Trolltech ASA. |
| ** |
| ** Contact: Qt Extended Information ([email protected]) |
| ** |
| ** This file may be used under the terms of the GNU General Public License |
| ** version 2.0 as published by the Free Software Foundation and appearing |
| ** in the file LICENSE.GPL included in the packaging of this file. |
| ** |
| ** Please review the following information to ensure GNU General Public |
| ** Licensing requirements will be met: |
| ** http://www.fsf.org/licensing/licenses/info/GPLv2.html. |
| ** |
| ** |
| ****************************************************************************/ |
| |
| #include <stdlib.h> |
| |
| #include <qsmsmessage.h> |
| #include "qsmsmessage_p.h" |
| #include <qatutils.h> |
| #include <qgsmcodec.h> |
| #ifdef Q_WS_QWS |
| #include <qtopialog.h> |
| #else |
| #include <qdebug.h> |
| #define qLog(dbgcat) if(1); else qDebug() |
| #endif |
| #include <qstringlist.h> |
| |
| #include <qtextcodec.h> |
| |
| const int Unit = 1; |
| |
| class QSMSMessagePartPrivate |
| { |
| public: |
| QSMSMessagePartPrivate( const QString& text ) |
| { |
| this->isText = true; |
| this->text = text; |
| this->position = 0; |
| } |
| QSMSMessagePartPrivate( const QString& mimeType, const QByteArray& data ) |
| { |
| this->isText = false; |
| this->mimeType = mimeType; |
| this->data = data; |
| this->position = 0; |
| } |
| QSMSMessagePartPrivate( const QString& mimeType, const QByteArray& data, uint position ) |
| { |
| this->isText = false; |
| this->mimeType = mimeType; |
| this->data = data; |
| this->position = position; |
| } |
| QSMSMessagePartPrivate( const QSMSMessagePartPrivate& part ) |
| { |
| this->isText = part.isText; |
| this->text = part.text; |
| this->mimeType = part.mimeType; |
| this->data = part.data; |
| this->position = part.position; |
| } |
| |
| bool isText; |
| QString text; |
| QString mimeType; |
| QByteArray data; |
| uint position; |
| }; |
| |
| class QSMSMessagePrivate |
| { |
| public: |
| QSMSMessagePrivate() |
| { |
| ref = 1; |
| mValidity = 2 * 24 * 60; // 2 days |
| mReplyRequest = false; |
| mStatusReportRequested = false; |
| mMessageType = QSMSMessage::Normal; |
| mCodec = 0; |
| mForceGsm = false; |
| mBestScheme = (QSMSDataCodingScheme)(-1); |
| mDataCodingScheme = -1; |
| mMessageClass = -1; |
| mProtocol = 0; |
| } |
| |
| ~QSMSMessagePrivate() |
| { |
| } |
| |
| /* Convert from minutes to GSM 03.40 specification (section 9.2.3.12). |
| - 0-143 = 0 to 12 hours in 5 minute increments (0 = 5 minutes). |
| - 144-167 = 12hrs30min to 24hrs in 30 minute increments. |
| - 168-196 = 2days to 30days in 1 day increments. |
| - 197-255 = 5weeks to 63weeks in 1 week increments. |
| */ |
| uint gsmValidityPeriod() |
| { |
| uint mins = mValidity; |
| |
| if ( mins < 5 ) |
| return 0; |
| |
| if ( mins <= 12 * 60 ) |
| return ((mins / 5) - 1); |
| |
| if ( mins <= 24 * 60 ) |
| return ((mins + 29 - (12 * 60 + 30)) / 30) + 144; |
| |
| uint days = (mins + (24 * 60 - 1)) / (24 * 60); |
| |
| if ( days <= 30 ) |
| return days - 2 + 168; |
| |
| if ( days <= 63 * 7 ) |
| return ((days + 6) / 7) - 5 + 197; |
| |
| return 255; |
| } |
| |
| void setGsmValidityPeriod(uint value) |
| { |
| if ( value <= 143 ) |
| mValidity = (value + 1) * 5; |
| else if ( value <= 167 ) |
| mValidity = (value - 143) * 30 + 12 * 60; |
| else if ( value <= 196 ) |
| mValidity = (value - 166) * 24 * 60; |
| else |
| mValidity = (value - 192) * 7 * 24 * 60; |
| } |
| |
| void copy( QSMSMessagePrivate *from ) |
| { |
| *this = *from; |
| mHeaders = from->mHeaders; |
| } |
| |
| QAtomicInt ref; |
| QTextCodec *mCodec; |
| QString mServiceCenter; |
| QString mRecipient; |
| QString mSender; |
| QDateTime mTimestamp; |
| uint mValidity; |
| bool mReplyRequest; |
| bool mStatusReportRequested; |
| bool mForceGsm; |
| QSMSMessage::MessageType mMessageType; |
| QSMSDataCodingScheme mBestScheme; |
| QByteArray mHeaders; |
| QList<QSMSMessagePart> mParts; |
| QString mCachedBody; |
| int mDataCodingScheme; |
| int mMessageClass; |
| int mProtocol; |
| }; |
| |
| /*! |
| \enum QSMSMessage::MessageType |
| Defines the type of an SMS message. |
| |
| \value Normal The message is a normal SMS message. |
| \value CellBroadCast The message is a cell broadcast message. |
| \value StatusReport The message is an SMS status report message. |
| */ |
| |
| /*! |
| \enum QSMSDataCodingScheme |
| Define the data coding scheme to use to encode SMS message text. |
| |
| \value QSMS_Compressed Flag that indicates that the data is compressed |
| (not used at present). |
| \value QSMS_MessageClass Flag that indicates the message class |
| (not used at present). |
| \value QSMS_DefaultAlphabet Use the default 7-bit GSM alphabet. |
| \value QSMS_8BitAlphabet Use the locale-specific 8-bit alphabet. |
| \value QSMS_UCS2Alphabet Use the UCS-2 16-bit alphabet. |
| \value QSMS_ReservedAlphabet Use the reserved alphabet |
| (not used at present). |
| */ |
| |
| /*! |
| \class QSMSMessagePart |
| \inpublicgroup QtTelephonyModule |
| |
| \brief The QSMSMessagePart class specifies a part within an SMS message. |
| |
| \ingroup telephony |
| \sa QSMSMessage |
| |
| QSMSMessage objects contain zero or more "parts", which describe |
| the contents of the SMS message. A part may be plain text, |
| or a binary stream tagged by a MIME type. |
| */ |
| |
| /*! |
| Constructs an empty SMS message part. |
| */ |
| QSMSMessagePart::QSMSMessagePart() |
| { |
| d = new QSMSMessagePartPrivate( QString() ); |
| } |
| |
| /*! |
| Constructs a new plain text SMS message part from the |
| string \a text. |
| */ |
| QSMSMessagePart::QSMSMessagePart( const QString& text ) |
| { |
| d = new QSMSMessagePartPrivate( text ); |
| } |
| |
| /*! |
| Constructs a new binary SMS message part with the specified |
| \a mimeType and \a data. |
| */ |
| QSMSMessagePart::QSMSMessagePart( const QString& mimeType, const QByteArray& data ) |
| { |
| d = new QSMSMessagePartPrivate( mimeType, data ); |
| } |
| |
| /*! |
| Constructs a new binary SMS message part with the specified |
| \a mimeType and \a data. The part is intended to be displayed |
| at \a position within a subsequent text part. |
| */ |
| QSMSMessagePart::QSMSMessagePart( const QString& mimeType, const QByteArray& data, uint position ) |
| { |
| d = new QSMSMessagePartPrivate( mimeType, data, position ); |
| } |
| |
| /*! |
| Constructs a copy of \a part. |
| */ |
| QSMSMessagePart::QSMSMessagePart( const QSMSMessagePart& part ) |
| { |
| d = new QSMSMessagePartPrivate( *(part.d) ); |
| } |
| |
| /*! |
| Destructs the QSMSMessagePart. |
| */ |
| QSMSMessagePart::~QSMSMessagePart() |
| { |
| delete d; |
| } |
| |
| /*! |
| Assigns a copy of \a part to this object. |
| */ |
| QSMSMessagePart& QSMSMessagePart::operator=( const QSMSMessagePart& part ) |
| { |
| if ( &part != this ) { |
| delete d; |
| d = new QSMSMessagePartPrivate( *(part.d) ); |
| } |
| return *this; |
| } |
| |
| /*! |
| Returns true if this SMS message part is plain text; or false if binary. |
| */ |
| bool QSMSMessagePart::isText() const |
| { |
| return d->isText; |
| } |
| |
| /*! |
| Returns the plain text contents of this SMS message part, |
| or QString() if it is not a text part. |
| */ |
| QString QSMSMessagePart::text() const |
| { |
| return d->text; |
| } |
| |
| /*! |
| Returns the MIME type associated with this SMS message part, |
| or QString() if it is not a binary part. |
| */ |
| QString QSMSMessagePart::mimeType() const |
| { |
| return d->mimeType; |
| } |
| |
| /*! |
| Returns the binary data associated with this SMS message part. |
| Returns and empty QByteArray if it is not a binary part. |
| */ |
| const QByteArray& QSMSMessagePart::data() const |
| { |
| return d->data; |
| } |
| |
| /*! |
| Returns the text position to display this SMS message part at. |
| */ |
| uint QSMSMessagePart::position() const |
| { |
| return d->position; |
| } |
| |
| /*! |
| \class QSMSMessage |
| \inpublicgroup QtTelephonyModule |
| |
| \brief The QSMSMessage class specifies the contents of an SMS message. |
| |
| This class is intended for use with QSMSReader and QSMSSender to process |
| SMS messages according to 3GPP TS 03.40 and 23.040. |
| |
| An incoming SMS message from QSMSReader will typically have text() and |
| sender() set. Other fields such as destinationPort() and |
| applicationData() may be set if the message is a WAP Push or SMS datagram |
| message rather than plain text. |
| |
| An outgoing SMS message sent via QSMSSender will need to have at least |
| recipient() and text() set. If the message is a WAP Push or SMS datagram |
| message rather than plain text, then destinationPort() and applicationData() |
| should also be set. |
| |
| Special header fields in SMS messages can be accessed with serviceCenter(), |
| replyRequest(), statusReportRequested(), validityPeriod(), timestamp(), |
| dataCodingScheme(), and protocol(). |
| |
| \ingroup telephony |
| */ |
| |
| /*! |
| Constructs an empty QSMSMessage. |
| */ |
| QSMSMessage::QSMSMessage() |
| { |
| d = new QSMSMessagePrivate; |
| } |
| |
| /*! |
| Constructs an QSMSMessage that is a copy of \a msg. |
| */ |
| QSMSMessage::QSMSMessage(const QSMSMessage &msg) |
| { |
| d = msg.d; |
| d->ref.ref(); |
| } |
| |
| /*! |
| Destructs the QSMSMessage. |
| */ |
| QSMSMessage::~QSMSMessage() |
| { |
| if ( !d->ref.deref() ) |
| delete d; |
| } |
| |
| QSMSMessagePrivate *QSMSMessage::dwrite() |
| { |
| // If we are the only user of the private object, return it as-is. |
| if ( d->ref == 1 ) |
| return d; |
| |
| // Create a new private object and copy the current contents into it. |
| QSMSMessagePrivate *newd = new QSMSMessagePrivate(); |
| newd->copy( d ); |
| if ( !d->ref.deref() ) |
| delete d; |
| d = newd; |
| return newd; |
| } |
| |
| /*! |
| Assigns a copy of \a msg to this object. |
| */ |
| QSMSMessage& QSMSMessage::operator=( const QSMSMessage &msg) |
| { |
| if ( d == msg.d ) |
| return *this; |
| |
| if ( !d->ref.deref() ) |
| delete d; |
| |
| d = msg.d; |
| d->ref.ref(); |
| |
| return *this; |
| } |
| |
| /*! |
| Sets the contents of this QSMSMessage to a single plain text |
| body containing \a str. This is for simple messages only. |
| Complex messages should be constructed part by part using |
| the addPart() method. |
| |
| \sa text() |
| */ |
| void QSMSMessage::setText(const QString &str) |
| { |
| clearParts(); |
| addPart( QSMSMessagePart( str ) ); |
| } |
| |
| /*! |
| Returns the contents of this QSMSMessage as a single plain text string. |
| If the message contains binary parts, they will not appear |
| in the result. This is for simple message viewers only. |
| Complex message viewers should iterate over the list returned |
| by parts(). |
| |
| \sa setText() |
| */ |
| QString QSMSMessage::text() const |
| { |
| // Handle the easy cases first. |
| if ( d->mParts.count() == 0 ) { |
| return QString(); |
| } else if ( d->mParts.count() == 1 && d->mParts[0].isText() ) { |
| return d->mParts[0].text(); |
| } else if ( d->mCachedBody.length() > 0 ) { |
| return d->mCachedBody; |
| } |
| |
| // We need the private structure to be writable to cache the body. |
| const_cast<QSMSMessage *>(this)->dwrite(); |
| |
| // Append all text parts to get the complete body. |
| QString body = QString(); |
| for ( int posn = 0; posn < d->mParts.count(); ++posn ) { |
| if ( d->mParts[posn].isText() ) { |
| body += d->mParts[posn].text(); |
| } |
| } |
| d->mCachedBody = body; |
| return body; |
| } |
| |
| /*! |
| If the message consists solely of characters in the 7-bit GSM |
| encoding, then the message will be transmitted that way. |
| Otherwise \a codec is used to convert the characters into an |
| appropriate language-specific 8-bit encoding. If \a codec is |
| set to NULL, then the default UCS-2 encoding for GSM messages |
| is used. |
| |
| \sa textCodec() |
| */ |
| void QSMSMessage::setTextCodec(QTextCodec *codec) |
| { |
| dwrite()->mCodec = codec; |
| } |
| |
| /*! |
| Returns the current 8-bit text codec, or NULL if none has |
| been set. |
| |
| \sa setTextCodec() |
| */ |
| QTextCodec *QSMSMessage::textCodec() const |
| { |
| return d->mCodec; |
| } |
| |
| /*! |
| If \a force is true, then the codec set by QSMSMessage::setTextCodec |
| is ignored and the 7-bit GSM encoding is always used. Setting this |
| flag increases the number of characters that can be sent in any |
| given SMS message, but may lose information. |
| |
| \sa forceGsm() |
| */ |
| void QSMSMessage::setForceGsm(bool force) |
| { |
| dwrite()->mForceGsm = force; |
| } |
| |
| /*! |
| Returns true if the 7-bit GSM encoding has been forced. |
| |
| \sa setForceGsm() |
| */ |
| bool QSMSMessage::forceGsm() const |
| { |
| return d->mForceGsm; |
| } |
| |
| /*! |
| Sets the SMS data coding \a scheme to use for this message. |
| Normally you won't need to call this unless the user has |
| somehow explicitly requested an override. By default, |
| the QSMSMessage class will choose the best scheme for you. |
| Should be set to one of \c QSMS_DefaultAlphabet, |
| \c QSMS_8BitAlphabet, or \c QSMS_UCS2Alphabet. |
| |
| \sa bestScheme() |
| */ |
| void QSMSMessage::setBestScheme(QSMSDataCodingScheme scheme) |
| { |
| dwrite()->mBestScheme = scheme; |
| } |
| |
| |
| /*! |
| Returns the best SMS data coding scheme to use for this |
| message, determined by an inspection of the plain text body parts. |
| |
| \sa setBestScheme() |
| */ |
| QSMSDataCodingScheme QSMSMessage::bestScheme() const |
| { |
| QTextCodec *codec = QAtUtils::codec( "gsm-noloss" ); |
| QString body = text(); |
| uint len = body.length(); |
| bool gsmSafe; |
| |
| // Did the user provide a scheme override? |
| if ( d->mBestScheme != (QSMSDataCodingScheme)(-1) ) |
| return d->mBestScheme; |
| |
| // Encode zero-length bodies in the default alphabet. |
| if ( len == 0 ) |
| return QSMS_DefaultAlphabet; |
| |
| // Always use GSM if we are forced to do so. |
| if ( d->mForceGsm ) |
| return QSMS_DefaultAlphabet; |
| |
| // Check the body for non-GSM characters. |
| gsmSafe = codec->canEncode( body ); |
| |
| // Use the default alphabet if everything is GSM-compatible. |
| if ( gsmSafe ) |
| return QSMS_DefaultAlphabet; |
| |
| // See if we can convert to 8-bit using the codec |
| // without losing any information. |
| if ( d->mCodec && d->mCodec->canEncode( body ) ) |
| return QSMS_8BitAlphabet; |
| |
| // Default to the UCS-2 alphabet. |
| return QSMS_UCS2Alphabet; |
| } |
| |
| /*! |
| Sets the recipient's telephone number to \a txt. |
| |
| \sa recipient() |
| */ |
| void QSMSMessage::setRecipient(const QString &txt) |
| { |
| dwrite()->mRecipient = txt; |
| } |
| |
| /*! |
| Returns the recipient's telephone number. Normally QString() |
| for an incoming message. |
| |
| \sa setRecipient() |
| */ |
| QString QSMSMessage::recipient() const |
| { |
| return d->mRecipient; |
| } |
| |
| /*! |
| Sets the sender's telephone number to \a txt. |
| |
| \sa sender() |
| */ |
| void QSMSMessage::setSender(const QString &txt) |
| { |
| dwrite()->mSender = txt; |
| } |
| |
| /*! |
| Returns the sender's telephone number. Normally QString() |
| for an outgoing message. |
| |
| \sa setSender() |
| */ |
| QString QSMSMessage::sender() const |
| { |
| return d->mSender; |
| } |
| |
| /*! |
| Sets the service center to use for transmitting this SMS message, |
| or QString() for the default service center, to \a str. |
| |
| \sa serviceCenter() |
| */ |
| void QSMSMessage::setServiceCenter(const QString &str) |
| { |
| dwrite()->mServiceCenter = str; |
| } |
| |
| /*! |
| Returns the service center. |
| |
| \sa setServiceCenter() |
| */ |
| QString QSMSMessage::serviceCenter() const |
| { |
| return d->mServiceCenter; |
| } |
| |
| /*! |
| Enable or disable the "reply request" flag for this SMS message, |
| according to the value of \a on. |
| |
| \sa replyRequest() |
| */ |
| void QSMSMessage::setReplyRequest(bool on ) |
| { |
| dwrite()->mReplyRequest = on; |
| } |
| |
| /*! |
| Returns the "reply request" flag. |
| |
| \sa setReplyRequest() |
| */ |
| bool QSMSMessage::replyRequest() const |
| { |
| return d->mReplyRequest; |
| } |
| |
| /*! |
| Sets the status report requested flag to \a on. |
| |
| \sa statusReportRequested() |
| */ |
| void QSMSMessage::setStatusReportRequested(bool on) |
| { |
| dwrite()->mStatusReportRequested = on; |
| } |
| |
| /*! |
| Returns true if status report requested flag is currently set;otherwise returns false. |
| |
| \sa setStatusReportRequested() |
| */ |
| bool QSMSMessage::statusReportRequested() const |
| { |
| return d->mStatusReportRequested; |
| } |
| |
| /*! |
| Sets the validity period to \a minutes. The default is 2 days. If the value |
| is set to \c{(uint)(-1)}, it indicates that the message should have no |
| validity period specified. |
| |
| \sa validityPeriod(), gsmValidityPeriod() |
| */ |
| void QSMSMessage::setValidityPeriod(uint minutes) |
| { |
| dwrite()->mValidity = minutes; |
| } |
| |
| /*! |
| Returns the validity period in minutes for this message. The default is 2 days. |
| If the value is \c{(uint)(-1)}, it indicates that the message should have no |
| validity period specified. |
| |
| \sa setValidityPeriod(), setGsmValidityPeriod() |
| */ |
| uint QSMSMessage::validityPeriod() const |
| { |
| return d->mValidity; |
| } |
| |
| /*! |
| Sets the GSM validity period to \a value, which must be between |
| 0 and 255, inclusive. The setValidity() method |
| is a friendlier way to set the validity value. |
| |
| 0 to 143 indicates 0 to 12 hours in 5 minute increments (0 = 5 minutes). |
| 144 to 167 indicates 12 hrs 30 min to 24 hrs in 30 minute increments. |
| 168 to 196 indicates 2 days to 30 days in 1 day increments. |
| 197 to 255 indicates 5 weeks to 63 weeks in 1 week increments. |
| |
| \sa gsmValidityPeriod(), validityPeriod() |
| */ |
| void QSMSMessage::setGsmValidityPeriod(uint value) |
| { |
| dwrite()->setGsmValidityPeriod(value); |
| } |
| |
| /*! |
| Returns the GSM validity period value, between 0 and 255, inclusive. |
| |
| \sa setGsmValidityPeriod(), setValidityPeriod() |
| */ |
| uint QSMSMessage::gsmValidityPeriod() const |
| { |
| return d->gsmValidityPeriod(); |
| } |
| |
| /*! |
| Sets the SMS message's \a timestamp. |
| |
| \sa timestamp() |
| */ |
| void QSMSMessage::setTimestamp(const QDateTime& timestamp) |
| { |
| dwrite()->mTimestamp = timestamp; |
| } |
| |
| /*! |
| Returns the SMS message's timestamp, which will be null if the |
| message does not have a timestamp. |
| |
| \sa setTimestamp() |
| */ |
| QDateTime QSMSMessage::timestamp() const |
| { |
| return d->mTimestamp; |
| } |
| |
| /*! |
| Returns the SMS message type. |
| |
| \sa setMessageType() |
| */ |
| QSMSMessage::MessageType QSMSMessage::messageType() const |
| { |
| return d->mMessageType; |
| } |
| |
| /*! |
| Sets the SMS message type to \a m. There is rarely any need to |
| set this to something other than QSMSMessage::Normal. |
| |
| \sa messageType() |
| */ |
| void QSMSMessage::setMessageType(MessageType m) |
| { |
| dwrite()->mMessageType = m; |
| } |
| |
| /*! |
| Sets the SMS message's user data headers to \a value. |
| |
| \sa headers() |
| */ |
| void QSMSMessage::setHeaders(const QByteArray& value) |
| { |
| dwrite()->mHeaders = value; |
| } |
| |
| /*! |
| Returns the SMS message's user data headers. |
| |
| \sa setHeaders() |
| */ |
| const QByteArray& QSMSMessage::headers() const |
| { |
| return d->mHeaders; |
| } |
| |
| /*! |
| Clear all body parts from this SMS message. |
| |
| \sa addPart(), addParts(), parts() |
| */ |
| void QSMSMessage::clearParts() |
| { |
| dwrite()->mParts.clear(); |
| dwrite()->mCachedBody = QString(); |
| } |
| |
| /*! |
| Add a new body \a part to this SMS message. |
| |
| \sa clearParts(), addParts(), parts() |
| */ |
| void QSMSMessage::addPart( const QSMSMessagePart& part ) |
| { |
| // We need a writable copy. |
| dwrite(); |
| |
| // Clear the part list if we have one empty text part. |
| if ( d->mParts.count() == 1 && |
| d->mParts[0].isText() && |
| d->mParts[0].text().length() == 0 ) { |
| d->mParts.clear(); |
| } |
| |
| // Append the new part and clear the cached text. |
| d->mParts.append( part ); |
| d->mCachedBody = QString(); |
| } |
| |
| /*! |
| Add a list of body \a parts to this SMS message. |
| |
| \sa clearParts(), addPart(), parts() |
| */ |
| void QSMSMessage::addParts( const QList<QSMSMessagePart>& parts ) |
| { |
| // We need a writable copy. |
| dwrite(); |
| |
| if ( d->mParts.count() == 1 && |
| d->mParts[0].isText() && |
| d->mParts[0].text().length() == 0 ) { |
| d->mParts.clear(); |
| } |
| d->mParts += parts; |
| d->mCachedBody = QString(); |
| } |
| |
| /*! |
| Returns a list of all body parts in this SMS message. |
| |
| \sa clearParts(), addParts(), addPart() |
| */ |
| QList<QSMSMessagePart> QSMSMessage::parts() const |
| { |
| return d->mParts; |
| } |
| |
| /*! |
| Compute an estimate for the number of messages that will need |
| to be used to send this SMS message (\a numMessages), and the |
| number of spare characters that are left in the last message |
| before it overflows (\a spaceLeftInLast). |
| |
| This function may be useful in user interfaces to indicate to |
| the user that an SMS message needs to be sent in multiple pieces, |
| costing the user more money. |
| */ |
| void QSMSMessage::computeSize( uint& numMessages, uint& spaceLeftInLast ) const |
| { |
| int part = findPart( "application/x-qtopia-wdp-ports" ); |
| if ( part != -1 ) { |
| // This is an application datagram, which has its size |
| // computed using a different algorithm. |
| uint headerLen = 3 + d->mParts[(uint)part].data().size(); |
| uint dataLen = applicationData().size(); |
| if ( ( headerLen + dataLen ) <= 140 ) { |
| numMessages = 1; |
| spaceLeftInLast = 134 - headerLen - dataLen; |
| } else { |
| uint partSize = ( 134 - headerLen ); |
| numMessages = ( dataLen + partSize - 1 ) / partSize; |
| spaceLeftInLast = dataLen - numMessages * partSize; |
| } |
| return; |
| } |
| |
| QSMSDataCodingScheme scheme = bestScheme(); |
| uint len; |
| QString body = text(); |
| |
| if ( scheme == QSMS_DefaultAlphabet ) { |
| |
| // Encode the message using 7-bit GSM. |
| len = body.length(); |
| if ( len <= 160 ) { |
| numMessages = 1; |
| spaceLeftInLast = 160 - len; |
| } else { |
| // 153 = 160 - fragment_header_size (7). |
| numMessages = ( len + 152 ) / 153; |
| len %= 153; |
| if ( len != 0 ) |
| spaceLeftInLast = 153 - len; |
| else |
| spaceLeftInLast = 0; |
| } |
| |
| } else if ( scheme == QSMS_8BitAlphabet ) { |
| |
| // Encode the message using an 8-bit character set. |
| QByteArray converted = d->mCodec->fromUnicode( body ); |
| len = converted.length(); |
| if ( len <= 140 ) { |
| numMessages = 1; |
| spaceLeftInLast = 140 - len; |
| } else { |
| // 134 = 140 - fragment_header_size (6). |
| numMessages = ( len + 133 ) / 134; |
| len %= 134; |
| if ( len != 0 ) |
| spaceLeftInLast = 134 - len; |
| else |
| spaceLeftInLast = 0; |
| } |
| |
| } else { |
| |
| // Encode the message with unicode. |
| len = body.length(); |
| if ( len <= 70 ) { |
| numMessages = 1; |
| spaceLeftInLast = 70 - len; |
| } else { |
| // 67 = 70 - fragment_header_size (3). |
| numMessages = ( len + 66 ) / 67; |
| len %= 67; |
| if ( len != 0 ) |
| spaceLeftInLast = 67 - len; |
| else |
| spaceLeftInLast = 0; |
| } |
| } |
| } |
| |
| /*! |
| Returns the destination port number if this SMS message contains |
| an application datagram, or -1 if not an application datagram. |
| |
| When an SMS message is received that has a destination port |
| number, Qt Extended will attempt to find a QDS service that can handle it. |
| Qt Extended first looks for a QDS service named \c push for the MIME type |
| \c T from the WAP push header. Next, it looks for a service named |
| \c push for the MIME type \c{application/x-smsapp-N} where |
| \c N is the port number in decimal. |
| |
| If a matching service is found, then the SMS message is |
| sent to the corresponding application via QDS. The QCop |
| message is that specified in the QDS service definition. |
| Thus, applications can register to receive special SMS messages. |
| |
| The following QDS definition, in \c{etc/qds/ContactsPhone} will |
| direct vcard's that are received via WAP to the \c ContactsPhone |
| service. The \c ContactsPhone service is normally implemented |
| by the \c addressbook program. |
| |
| \code |
| [Translation] |
| File=QtopiaServices |
| Context=ContactsPhone |
| [pushVCard] |
| RequestDataType=text/x-vcard |
| ResponseDataType= |
| Attributes="push" |
| Description[]=Receive a vcard via WAP push |
| \endcode |
| |
| The \c Attributes must contain \c push and the \c RequestDataType |
| must be the MIME type to be dispatched. The QCop message that is |
| delivered to the application will have the name |
| \c pushVCard(QDSActionRequest). The data in the action request |
| will be the payload of the push message. |
| |
| The auxilary data in the action request will be a QByteArray |
| containing the full QSMSMessage object, from which the application |
| can extra header information if it needs it. Use the QSMSMessage |
| datastream operators to extract the QSMSMessage object. |
| |
| If the application fails to process an SMS message that is sent to |
| it via QCop, then it will be lost. It is important that such |
| applications take steps to save the message if necessary. |
| |
| If a matching service is not found, then the SMS message |
| will be delivered to the \c qtmail application normally, |
| and then saved by that application. |
| |
| \sa setDestinationPort(), sourcePort() |
| */ |
| int QSMSMessage::destinationPort() const |
| { |
| int part = findPart( "application/x-qtopia-wdp-ports" ); |
| if ( part == -1 ) |
| return -1; |
| |
| QByteArray data = d->mParts[(uint)part].data(); |
| if ( data.size() == 4 ) { |
| |
| return ((((int)(data[0])) & 0xFF) << 8) | |
| (((int)(data[1])) & 0xFF); |
| |
| } else if ( data.size() == 2 ) { |
| |
| return (((int)(data[0])) & 0xFF); |
| } |
| |
| return -1; |
| } |
| |
| /*! |
| Sets the destination port number for an SMS message that contains |
| an application datagram to \a value. |
| |
| \sa destinationPort(), sourcePort() |
| */ |
| void QSMSMessage::setDestinationPort(int value) |
| { |
| QByteArray data; |
| int source; |
| int part = findPart( "application/x-qtopia-wdp-ports" ); |
| if ( part == -1 ) { |
| data.resize(4); |
| data[0] = (char)(value >> 8); |
| data[1] = (char)value; |
| data[2] = (char)0; |
| data[3] = (char)0; |
| } else { |
| source = sourcePort(); |
| data.resize(4); |
| data[0] = (char)(value >> 8); |
| data[1] = (char)value; |
| data[2] = (char)(source >> 8); |
| data[3] = (char)source; |
| } |
| removeParts( "application/x-qtopia-wdp-ports" ); |
| addPart( QSMSMessagePart( "application/x-qtopia-wdp-ports", data ) ); |
| } |
| |
| /*! |
| Returns the source port number if this SMS message contains |
| an application datagram, or -1 if not an application datagram. |
| |
| \sa setSourcePort(), destinationPort() |
| */ |
| int QSMSMessage::sourcePort() const |
| { |
| int part = findPart( "application/x-qtopia-wdp-ports" ); |
| if ( part == -1 ) |
| return -1; |
| |
| QByteArray data = d->mParts[(uint)part].data(); |
| if ( data.size() == 4 ) { |
| |
| return ((((int)(data[2])) & 0xFF) << 8) | |
| (((int)(data[3])) & 0xFF); |
| |
| } else if ( data.size() == 2 ) { |
| |
| return (((int)(data[1])) & 0xFF); |
| } |
| |
| return -1; |
| } |
| |
| /*! |
| Sets the source port number for an SMS message that contains |
| an application datagram to \a value. |
| |
| \sa sourcePort(), destinationPort() |
| */ |
| void QSMSMessage::setSourcePort(int value) |
| { |
| QByteArray data; |
| int dest; |
| int part = findPart( "application/x-qtopia-wdp-ports" ); |
| if ( part == -1 ) { |
| data.resize(4); |
| data[0] = (char)0; |
| data[1] = (char)0; |
| data[2] = (char)(value >> 8); |
| data[3] = (char)value; |
| } else { |
| dest = destinationPort(); |
| data.resize(4); |
| data[0] = (char)(dest >> 8); |
| data[1] = (char)dest; |
| data[2] = (char)(value >> 8); |
| data[3] = (char)value; |
| } |
| removeParts( "application/x-qtopia-wdp-ports" ); |
| addPart( QSMSMessagePart( "application/x-qtopia-wdp-ports", data ) ); |
| } |
| |
| /*! |
| Returns the data if this SMS message contains an application datagram. |
| Returns an empty byte array if this message is not a datagram. |
| |
| \sa setApplicationData() |
| */ |
| QByteArray QSMSMessage::applicationData() const |
| { |
| QByteArray data; |
| QList<QSMSMessagePart>::ConstIterator iter; |
| uint size; |
| for ( iter = d->mParts.begin(); iter != d->mParts.end(); ++iter ) { |
| if ( (*iter).mimeType() == "application/x-qtopia-wdp" ) { |
| size = data.size(); |
| data.resize( size + (*iter).data().size() ); |
| memcpy( data.data() + size, (*iter).data().data(), |
| (*iter).data().size() ); |
| } |
| } |
| return data; |
| } |
| |
| /*! |
| Sets the data within an SMS message that contains an application |
| datagram to \a value. |
| |
| \sa applicationData() |
| */ |
| void QSMSMessage::setApplicationData(const QByteArray& value) |
| { |
| removeParts( "application/x-qtopia-wdp" ); |
| addPart( QSMSMessagePart( "application/x-qtopia-wdp", value ) ); |
| } |
| |
| /*! |
| Sets the data coding scheme to use within an SMS message to \a value. |
| If \a value is -1, then the system chooses the best data coding scheme |
| based on the content. |
| |
| This method is mainly of use with application datagrams, not text |
| SMS messages. |
| |
| \sa dataCodingScheme() |
| */ |
| void QSMSMessage::setDataCodingScheme(int value) |
| { |
| dwrite()->mDataCodingScheme = value; |
| } |
| |
| /*! |
| Returns the data coding scheme to use within an SMS message. |
| If the value is -1, then the system chooses the best data coding scheme |
| based on the content. |
| |
| This method is mainly of use with application datagrams, not text |
| SMS messages. |
| |
| \sa setDataCodingScheme() |
| */ |
| int QSMSMessage::dataCodingScheme() const |
| { |
| return d->mDataCodingScheme; |
| } |
| |
| /*! |
| Sets the message class for this message to \a value. The \value should |
| be -1 if the system should choose a default message class. The message |
| class should otherwise be 0, 1, 2, or 3, according to 3GPP TS 03.38. |
| */ |
| void QSMSMessage::setMessageClass(int value) |
| { |
| dwrite()->mMessageClass = value; |
| } |
| |
| /*! |
| Get the message class for this message, or -1 if the system should |
| choose a default message class. The message class should otherwise |
| be 0, 1, 2, or 3, according to 3GPP TS 03.38. |
| */ |
| int QSMSMessage::messageClass() const |
| { |
| return d->mMessageClass; |
| } |
| |
| /*! |
| Sets the SMS message's protocol field to \a value. |
| |
| \sa protocol() |
| */ |
| void QSMSMessage::setProtocol(int value) |
| { |
| dwrite()->mProtocol = value; |
| } |
| |
| /*! |
| Returns the SMS message's protocol field. |
| |
| \sa setProtocol() |
| */ |
| int QSMSMessage::protocol() const |
| { |
| return d->mProtocol; |
| } |
| |
| /*! |
| Returns true if this message needs to be split into multiple messages |
| before being transmitted over a GSM network; otherwise returns false. |
| |
| \sa split() |
| */ |
| bool QSMSMessage::shouldSplit() const |
| { |
| uint numMessages, spaceLeftInLast; |
| this->computeSize( numMessages, spaceLeftInLast ); |
| return ( numMessages <=1 ? false : true ); |
| } |
| |
| /*! |
| Split this message into several messages of smaller size for |
| transmission over a GSM network. |
| |
| \sa shouldSplit() |
| */ |
| QList<QSMSMessage> QSMSMessage::split() const |
| { |
| QList<QSMSMessage> list; |
| uint numMessages, spaceLeftInLast; |
| static uint fragmentCounter =0; |
| |
| computeSize( numMessages, spaceLeftInLast ); |
| if ( numMessages <= 1 ) { |
| // Splitting is not necessary, so return a list with one message. |
| list += *this; |
| return list; |
| } |
| |
| // Get the number of characters to transmit in each fragment. |
| int split; |
| QSMSDataCodingScheme scheme = bestScheme(); |
| switch ( scheme ) { |
| case QSMS_DefaultAlphabet: split = 153; break; |
| case QSMS_8BitAlphabet: split = 134; break; |
| default: split = 67; break; |
| } |
| |
| // Split the message to create sub-messages and transmit them. |
| int posn = 0; |
| int len; |
| uint number; |
| QSMSMessage tmp; |
| number = 1; |
| if ( destinationPort() == -1 ) { |
| // Splitting a simple text message. |
| QString txt = text(); |
| while ( posn < txt.length() ) { |
| tmp = *this; |
| len = txt.length() - posn; |
| if ( len > split ) { |
| len = split; |
| } |
| tmp.setText( txt.mid( posn, len ) ); |
| tmp.setFragmentHeader( fragmentCounter, number++, |
| numMessages, scheme ); |
| posn += len; |
| list.append(tmp); |
| } |
| } else { |
| // Splitting a datagram message. |
| QByteArray data = applicationData(); |
| QByteArray part; |
| uint partSize = 134 - 6; |
| while ( posn < data.size() ) { |
| tmp = *this; |
| if ( ( posn + partSize ) <= (uint)data.size() ) { |
| part.resize(partSize); |
| memcpy(part.data(), data.data() + posn, partSize ); |
| } else { |
| part.resize(data.size() - posn); |
| memcpy(part.data(), data.data() + posn, data.size() - posn); |
| } |
| tmp.setDestinationPort( destinationPort() );// Force 16-bit ports. |
| tmp.setFragmentHeader( fragmentCounter, number++, |
| numMessages, QSMS_8BitAlphabet ); |
| tmp.setApplicationData( part ); |
| list.append(tmp); |
| posn += partSize; |
| } |
| } |
| |
| // Increase the fragment counter for the next multi-part SMS message. |
| fragmentCounter = ( fragmentCounter + 1 ) & 0xFF; |
| |
| return list; |
| } |
| |
| /*! |
| Convert this SMS message into its binary PDU form, according to |
| 3GPP TS 03.40 and 3GPP TS 23.040. If the message has a recipient, |
| then a SUBMIT message will be constructed. If the message does not |
| have a recipient, then a DELIVER message will be constructed. |
| |
| \sa fromPdu() |
| */ |
| QByteArray QSMSMessage::toPdu() const |
| { |
| QSMSSubmitMessage submit( *this, recipient().isEmpty() ); |
| return submit.toByteArray(); |
| } |
| |
| /*! |
| Convert a binary \a pdu into an SMS message, according to |
| 3GPP TS 03.40 and 3GPP TS 23.040. |
| |
| \sa toPdu() |
| */ |
| QSMSMessage QSMSMessage::fromPdu( const QByteArray& pdu ) |
| { |
| QSMSDeliverMessage pdumsg( pdu ); |
| return pdumsg.unpack(); |
| } |
| |
| /*! |
| Returns the length of the service center address on the start of \a pdu. |
| This is typically used with AT-based GSM modems that need to transmit |
| the length of the pdu, excluding the service center address, |
| along with the \c{AT+CMGS} command. |
| */ |
| int QSMSMessage::pduAddressLength( const QByteArray& pdu ) |
| { |
| if( pdu.length() > 0 ) |
| return (pdu[0] & 0xFF) + 1; |
| else |
| return 0; |
| } |
| |
| int QSMSMessage::findPart( const QString& mimeType ) const |
| { |
| QList<QSMSMessagePart>::ConstIterator iter; |
| int posn = 0; |
| for ( iter = d->mParts.begin(); iter != d->mParts.end(); ++iter ) { |
| if ( (*iter).mimeType() == mimeType ) |
| return posn; |
| ++posn; |
| } |
| return -1; |
| } |
| |
| void QSMSMessage::removeParts( const QString& mimeType ) |
| { |
| dwrite(); |
| QList<QSMSMessagePart>::Iterator iter; |
| for ( iter = d->mParts.begin(); iter != d->mParts.end(); ) { |
| if ( (*iter).mimeType() == mimeType ) { |
| iter = d->mParts.erase( iter ); |
| } else { |
| ++iter; |
| } |
| } |
| } |
| |
| void QSMSMessage::setFragmentHeader( uint refNum, uint part, uint numParts, |
| QSMSDataCodingScheme scheme ) |
| { |
| dwrite()->mBestScheme = scheme; |
| uint len = d->mHeaders.size(); |
| d->mHeaders.resize( len + 5 ); |
| d->mHeaders[len++] = 0; // Type for concatenated short messages. |
| d->mHeaders[len++] = 3; // Length of header information. |
| d->mHeaders[len++] = (char)refNum; |
| d->mHeaders[len++] = (char)numParts; |
| d->mHeaders[len++] = (char)part; |
| } |
| |
| |
| void QSMSMessage::unpackHeaderParts() |
| { |
| QByteArray headers = dwrite()->mHeaders; |
| uint posn = 0; |
| uint tag, len; |
| uint temp; |
| QString type; |
| while ( ( posn + 2 ) <= (uint)(headers.size()) ) { |
| tag = (unsigned char)(headers[posn]); |
| len = (unsigned char)(headers[posn + 1]); |
| if ( ( posn + len + 2 ) > (uint)(headers.size()) ) |
| break; |
| switch ( (SMSHeaderKind)tag ) { |
| |
| case SMS_HK_Predefined_Sound: |
| { |
| // Predefined sound type. |
| if ( len >= 2 ) { |
| QByteArray data( len - 1, 0 ); |
| memcpy( data.data(), headers.data() + posn + 3, len - 1 ); |
| addPart( QSMSMessagePart |
| ( "application/x-qtopia-predefined-sound", data, |
| headers[posn + 2] & 0xFF ) ); |
| } |
| } |
| break; |
| |
| case SMS_HK_User_Defined_Sound: |
| { |
| // User defined sound type. |
| if ( len >= 2 ) { |
| QByteArray data( len - 1, 0 ); |
| memcpy( data.data(), headers.data() + posn + 3, len - 1 ); |
| addPart( QSMSMessagePart |
| ( "audio/imelody", data, headers[posn + 2] & 0xFF ) ); |
| } |
| } |
| break; |
| |
| case SMS_HK_Predefined_Animation: |
| { |
| // Predefined animation type. |
| if ( len >= 2 ) { |
| QByteArray data( len - 1, 0 ); |
| memcpy( data.data(), headers.data() + posn + 3, len - 1 ); |
| addPart( QSMSMessagePart |
| ( "application/x-qtopia-predefined-animation", data, |
| headers[posn + 2] & 0xFF ) ); |
| } |
| } |
| break; |
| |
| case SMS_HK_Large_Animation: |
| case SMS_HK_Large_Picture: |
| { |
| // 32x32 monochrome animation or image - turn it into a WBMP. |
| if ( len >= 1 ) { |
| QByteArray data( len + 3, 0 ); |
| data[0] = 0x00; |
| data[1] = 0x00; |
| data[2] = 0x20; |
| data[3] = 0x20; |
| for ( temp = 0; temp < (len - 1); ++temp ) { |
| data[4 + temp] = (char)(~(headers[posn + 3 + temp])); |
| } |
| addPart( QSMSMessagePart |
| ( "image/vnd.wap.wbmp", data, |
| headers[posn + 2] & 0xFF ) ); |
| } |
| } |
| break; |
| |
| case SMS_HK_Small_Animation: |
| case SMS_HK_Small_Picture: |
| { |
| // 16x16 monochrome animation or image - turn it into a WBMP. |
| if ( len >= 1 ) { |
| QByteArray data( len + 3, 0 ); |
| data[0] = 0x00; |
| data[1] = 0x00; |
| data[2] = 0x10; |
| data[3] = 0x10; |
| for ( temp = 0; temp < (len - 1); ++temp ) { |
| data[4 + temp] = (char)(~(headers[posn + 3 + temp])); |
| } |
| addPart( QSMSMessagePart |
| ( "image/vnd.wap.wbmp", data, |
| headers[posn + 2] & 0xFF ) ); |
| } |
| } |
| break; |
| |
| case SMS_HK_Variable_Picture: |
| { |
| // Variable-sized monochrome image - turn it into a WBMP. |
| if ( len >= 3 ) { |
| QByteArray data( len - 1, 0 ); |
| data[0] = 0x00; |
| data[1] = 0x00; |
| data[2] = headers[posn + 3]; |
| data[3] = headers[posn + 4]; |
| for ( temp = 2; temp < (len - 1); ++temp ) { |
| data[2 + temp] = (char)(~(headers[posn + 3 + temp])); |
| } |
| addPart( QSMSMessagePart |
| ( "image/vnd.wap.wbmp", data, |
| headers[posn + 2] & 0xFF ) ); |
| } |
| } |
| break; |
| |
| case SMS_HK_Concat_8Bit: break; |
| case SMS_HK_Concat_16Bit: break; |
| |
| case SMS_HK_AppPort_8Bit: |
| case SMS_HK_AppPort_16Bit: |
| { |
| QByteArray data( len, 0 ); |
| memcpy( data.data(), headers.data() + posn + 2, len ); |
| addPart( QSMSMessagePart |
| ( "application/x-qtopia-wdp-ports", data ) ); |
| } |
| break; |
| |
| default: |
| { |
| // Add the unknown part as "application/x-qtopia-sms-N". |
| // Maybe qtmail will know what to do with it. |
| QByteArray data( len, 0 ); |
| memcpy( data.data(), headers.data() + posn + 2, len ); |
| addPart( QSMSMessagePart( "application/x-qtopia-sms-" + |
| QString::number( tag ), data ) ); |
| } |
| break; |
| } |
| posn += 2 + len; |
| } |
| } |
| |
| QPDUMessage::QPDUMessage() |
| { |
| mPosn = 0; |
| mBits = 0; |
| } |
| |
| QPDUMessage::QPDUMessage(const QByteArray &data) |
| { |
| mBuffer = data; |
| mPosn = 0; |
| mBits = 0; |
| } |
| |
| QPDUMessage::~QPDUMessage() |
| { |
| } |
| |
| QPDUMessage::QPDUMessage(const QPDUMessage &msg) |
| { |
| mBuffer = msg.mBuffer; |
| mPosn = msg.mPosn; |
| mBits = msg.mBits; |
| } |
| |
| void QPDUMessage::skipOctet() |
| { |
| if ( mPosn < mBuffer.size() ) |
| ++mPosn; |
| } |
| |
| QByteArray QPDUMessage::getOctets( uint len ) |
| { |
| QByteArray result; |
| if ( ( mBuffer.size() - mPosn ) < (int)len ) { |
| result = mBuffer.mid( mPosn ); |
| abort(); |
| } else { |
| result = mBuffer.mid( mPosn, (int)len ); |
| mPosn += len; |
| } |
| return result; |
| } |
| |
| int QPDUMessage::mPosn; |
| char QPDUMessage::mBits; |
| |
| void QPDUMessage::setBit(int b, bool on) |
| { |
| if ( on ) |
| mBits |= (char)(Unit << b); |
| else |
| mBits &= (char)(~(Unit << b)); |
| } |
| |
| void QPDUMessage::setBits(int offset, int len, int val) |
| { |
| uint mask = ((Unit << len) - 1) << offset; |
| mBits = (char)((mBits & ~mask) | ((val << offset) & mask)); |
| } |
| |
| void QPDUMessage::commitBits() |
| { |
| mBuffer += mBits; |
| mBits = 0; |
| } |
| |
| void QPDUMessage::commitBits( QByteArray &buffer ) |
| { |
| buffer += mBits; |
| mBits = 0; |
| } |
| |
| bool QPDUMessage::bit(int b) |
| { |
| if ( needOctets(1) ) |
| return (mBuffer[mPosn] & (Unit << b)); |
| else |
| return 0; |
| } |
| |
| unsigned char QPDUMessage::bits(int offset, int len) |
| { |
| if ( needOctets(1) ) |
| return (unsigned char) |
| ((mBuffer[mPosn] >> offset) & ((Unit << len) - 1)); |
| else |
| return 0; |
| } |
| |
| unsigned char QPDUMessage::getOctet() |
| { |
| if ( needOctets(1) ) |
| return (unsigned char)(mBuffer[mPosn++]); |
| else |
| return 0; |
| } |
| |
| unsigned char QPDUMessage::peekOctet() const |
| { |
| if ( needOctets(1) ) |
| return (unsigned char)(mBuffer[mPosn]); |
| else |
| return 0; |
| } |
| |
| // Collapse 8-bit-aligned GSM data to its 7-bit form. |
| static QByteArray collapse7Bit( const QByteArray& in ) |
| { |
| QByteArray out; |
| int byte = 0; |
| int size = 0; |
| for ( int posn = 0; posn < in.length(); ++posn ) { |
| for ( int bit = 0; bit < 7; ++bit ) { |
| if ( ( in[posn] & (1 << bit) ) != 0 ) |
| byte |= (1 << size); |
| ++size; |
| if ( size >= 8 ) { |
| out += (char)byte; |
| byte = 0; |
| size = 0; |
| } |
| } |
| } |
| if ( size != 0 ) { |
| out += (char)byte; |
| } |
| return out; |
| } |
| |
| void QPDUMessage::appendAddress( QByteArray &buffer, const QString &strin, bool SCAddress ) |
| { |
| SMSAddressType at; |
| int len, digit, octet; |
| int posn; |
| const int maxPhoneNumberLen = 15; |
| QString str( strin ); |
| str.truncate( maxPhoneNumberLen ); |
| |
| // Determine the address type and length. |
| at = SMS_Address_Unknown; |
| len = 0; |
| for ( posn = 0; posn < str.length(); ++posn ) { |
| switch ( str[posn].unicode() ) { |
| case '+': |
| at = SMS_Address_International; |
| break; |
| |
| case '0': case '1': case '2': case '3': |
| case '4': case '5': case '6': case '7': |
| case '8': case '9': case '*': case '#': |
| case 'A': case 'B': case 'C': case 'a': |
| case 'b': case 'c': |
| ++len; |
| break; |
| |
| default: |
| // Probably an alpha-numeric address. |
| ++len; |
| at = SMS_Address_AlphaNumeric; |
| break; |
| } |
| } |
| if ( SCAddress ) |
| len = (len + 1) / 2; |
| |
| // Bail out early if the address is zero-length. |
| if ( !len ) { |
| buffer.append( (char) 0 ); |
| return; |
| } |
| |
| // Handle alphanumeric address fields. |
| if ( at == SMS_Address_AlphaNumeric ) { |
| // Convert the address and calculate its encoded length. |
| QTextCodec *codec = QAtUtils::codec( "gsm-noloss" ); |
| QByteArray bytes = collapse7Bit( codec->fromUnicode( strin ) ); |
| len = bytes.size(); |
| |
| // Need an extra byte for SCAddress fields. |
| if ( SCAddress ) |
| len++; |
| else |
| len *= 2; |
| |
| // Output the length of the encoded address. |
| buffer.append( len ); |
| |
| // Output the type of number information. |
| setBits(0, 4, SMS_NumberId_Unknown); |
| setBits(4, 3, at); |
| setBit(7, true); |
| commitBits( buffer ); |
| |
| // Output the encoded address and exit. |
| buffer += bytes; |
| return; |
| } |
| |
| // SCAddress len = octets + type specifier |
| if ( SCAddress ) |
| len++; |
| |
| buffer.append( len ); |
| |
| setBits(0, 4, SMS_Phone); |
| setBits(4, 3, at); |
| setBit(7, true); |
| commitBits( buffer ); |
| |
| bool upper4 = false; |
| octet = 0; |
| for ( posn = 0; posn < str.length(); posn++ ) { |
| switch ( str[posn].unicode() ) { |
| case '0': digit = 0; break; |
| case '1': digit = 1; break; |
| case '2': digit = 2; break; |
| case '3': digit = 3; break; |
| case '4': digit = 4; break; |
| case '5': digit = 5; break; |
| case '6': digit = 6; break; |
| case '7': digit = 7; break; |
| case '8': digit = 8; break; |
| case '9': digit = 9; break; |
| case '*': digit = 10; break; |
| case '#': digit = 11; break; |
| case 'A': case 'a': digit = 12; break; |
| case 'B': case 'b': digit = 13; break; |
| case 'C': case 'c': digit = 14; break; |
| default: digit = -1; break; |
| } |
| if ( digit != -1 ) { |
| if ( !upper4 ) { |
| octet = digit; |
| } else { |
| octet |= (digit << 4); |
| buffer.append( octet ); |
| } |
| upper4 = !upper4; |
| } |
| } |
| if ( upper4 ) { |
| buffer.append( octet | 0xF0 ); |
| } |
| } |
| |
| void QPDUMessage::setAddress(const QString &strin, bool SCAddress) |
| { |
| appendAddress( mBuffer, strin, SCAddress ); |
| } |
| |
| void QSMSMessage::appendAddress( QByteArray &buffer, const QString &strin, bool SCAddress ) |
| { |
| return QPDUMessage::appendAddress( buffer, strin, SCAddress ); |
| } |
| |
| // Expand the 7-bit GSM data to 8-bit-aligned characters. |
| static QByteArray expand7Bit( const QByteArray& in ) |
| { |
| QByteArray out; |
| int byte = 0; |
| int size = 0; |
| for ( int posn = 0; posn < in.length(); ++posn ) { |
| for ( int bit = 0; bit < 8; ++bit ) { |
| if ( ( in[posn] & (1 << bit) ) != 0 ) |
| byte |= (1 << size); |
| ++size; |
| if ( size >= 7 ) { |
| out += (char)byte; |
| byte = 0; |
| size = 0; |
| } |
| } |
| } |
| return out; |
| } |
| |
| QString QPDUMessage::address(bool SCAddress) |
| { |
| QString str = ""; |
| |
| // Get the address length and validate it. |
| if ( !needOctets(1) ) |
| return str; |
| uint len = (((uint)(getOctet())) & 0xFF); |
| if ( !needOctets(len) ) { |
| abort(); |
| return str; |
| } |
| |
| if ( len ) { |
| SMSAddressType at = (SMSAddressType) bits(4, 3); |
| |
| if ( at == SMS_Address_International ) |
| str += "+"; |
| |
| skipOctet(); |
| if ( !SCAddress ) { |
| len = len / 2 + (len % 2); |
| } else { |
| len--; |
| } |
| |
| if ( at != SMS_Address_AlphaNumeric ) { |
| unsigned char c; |
| for (int i = 0; i < (int)len; i++) { |
| c = peekOctet() & 0x0F; |
| str += (char) ('0' + c); |
| c = (peekOctet() & 0xF0) >> 4; |
| if ( c != 0xf ) |
| str += (char) ('0' + c); |
| skipOctet(); |
| } |
| } else { |
| // Recognize an alphanumeric address in the 7-bit GSM encoding. |
| QTextCodec *codec = QAtUtils::codec( "gsm" ); |
| QByteArray bytes = expand7Bit( getOctets( len ) ); |
| str += codec->toUnicode( bytes ); |
| } |
| } |
| |
| return str; |
| } |
| |
| // Return the length of the service centre address. |
| uint QPDUMessage::addressLength() const |
| { |
| if( mPosn < mBuffer.size() ) |
| return (((uint)peekOctet()) & 0xFF) + 1; |
| else |
| return 0; |
| } |
| |
| void QPDUMessage::setTimeStamp(const QDateTime &dt) |
| { |
| QDate date = dt.date(); |
| int tArr[6]; |
| tArr[0] = date.year(); |
| tArr[1] = date.month(); |
| tArr[2] = date.day(); |
| |
| QTime t = dt.time(); |
| tArr[3] = t.hour(); |
| tArr[4] = t.minute(); |
| tArr[5] = t.second(); |
| |
| for ( int i = 0; i < 6; i++) { |
| appendOctet((unsigned char) ( (((tArr[i]/10)%10) & 0x0F) | (((tArr[i]%10) & 0x0F)<<4) ) ); |
| } |
| |
| appendOctet(0x04); //arbitrary random timezone |
| } |
| |
| QDateTime QPDUMessage::timeStamp() |
| { |
| QDateTime d; |
| unsigned char c, c4, date[7]; |
| |
| if ( !needOctets(7) ) { |
| abort(); |
| return d; |
| } |
| for (int i = 0; i < 7; i++) { |
| c = (peekOctet() & 0x0F); |
| c4 = (peekOctet() & 0xF0) >> 4; |
| date[i] = c*10 + c4; |
| skipOctet(); |
| } |
| |
| if ( date[0] < 80 ) { |
| d.setDate( QDate(2000 + date[0], date[1], date[2]) ); |
| } else { |
| d.setDate( QDate(1900 + date[0], date[1], date[2]) ); |
| } |
| d.setTime( QTime(date[3], date[4], date[5]) ); |
| |
| return d; |
| } |
| |
| // Get the length of a string when encoded in the GSM 7-bit alphabet. |
| static uint getEncodedLength( const QString& txt, uint size ) |
| { |
| uint len = 0; |
| for ( int u = 0; u < (int)size; u++ ) { |
| if ( QGsmCodec::twoByteFromUnicode( txt[u].unicode() ) >= 256 ) |
| len += 2; |
| else |
| ++len; |
| } |
| return len; |
| } |
| |
| void QPDUMessage::setUserData(const QString &txt, QSMSDataCodingScheme scheme, QTextCodec *codec, const QByteArray& headers, bool implicitLength) |
| { |
| uint len = txt.length(); |
| uint u; |
| uint encodedLen; |
| uint headerLen = (uint)(headers.size()); |
| if ( headerLen ) |
| ++headerLen; |
| |
| // Strip off everything except the alphabet bits. |
| switch (scheme >> 6) { |
| case 0: |
| default: |
| scheme = (QSMSDataCodingScheme)(scheme & 0x0C); |
| break; |
| case 3: |
| switch ((scheme & 0x30) >> 4) { |
| case 0: |
| case 1: |
| scheme = QSMS_DefaultAlphabet; |
| break; |
| case 2: |
| scheme = QSMS_UCS2Alphabet; |
| break; |
| case 3: |
| if (scheme & 0x4) |
| scheme = QSMS_8BitAlphabet; |
| else |
| scheme = QSMS_DefaultAlphabet; |
| break; |
| } |
| break; |
| } |
| |
| if ( scheme == QSMS_DefaultAlphabet ) { |
| |
| // Encode the text using the 7-bit GSM alphabet. |
| if ( len > 160 ) |
| len = 160; |
| encodedLen = getEncodedLength( txt, len ); |
| while ( encodedLen > 160 ) { |
| // Chop off some more characters until it is <= 160. |
| --len; |
| encodedLen = getEncodedLength( txt, len ); |
| } |
| if (!implicitLength) |
| appendOctet( encodedLen + ( headerLen * 8 + 6 ) / 7 ); |
| int bitCount = 0; |
| unsigned short c; |
| if ( headerLen > 0 ) { |
| // Output the header and align on a septet boundary. |
| bitCount = headerLen * 8; |
| if ((bitCount % 7) != 0) |
| bitCount = 7 - (bitCount % 7); |
| else |
| bitCount = 0; |
| appendOctet( headerLen - 1 ); |
| for ( u = 0; u < headerLen - 1; u++ ) { |
| appendOctet( headers[u] ); |
| } |
| } |
| for ( u = 0; u < len; u++ ) { |
| c = QGsmCodec::twoByteFromUnicode( txt[u].unicode() ); |
| if ( c >= 256 ) { |
| // Encode a two-byte sequence. |
| for ( int i = 0; i < 7; i++ ) { |
| if ( bitCount == 8 ) { |
| bitCount = 0; |
| commitBits(); |
| } |
| setBit( bitCount++, (Unit << (i+8)) & c ); |
| } |
| } |
| for ( int i = 0; i < 7; i++ ) { |
| if ( bitCount == 8 ) { |
| bitCount = 0; |
| commitBits(); |
| } |
| setBit( bitCount++, (Unit << i) & c ); |
| } |
| } |
| if ( bitCount != 0 ) { |
| commitBits(); |
| } |
| |
| } else if ( scheme == QSMS_8BitAlphabet ) { |
| // Encode the text using the codec's 8-bit alphabet. |
| if ( !codec ) |
| codec = QAtUtils::codec( "iso-8859-1" ); |
| QByteArray converted = codec->fromUnicode( txt ); |
| len = converted.length(); |
| if ( len > 140 ) |
| len = 140; |
| if (!implicitLength) |
| appendOctet( len + headerLen ); |
| if ( headerLen > 0 ) { |
| appendOctet( headerLen - 1 ); |
| for ( u = 0; u < headerLen - 1; u++ ) { |
| appendOctet( headers[u] ); |
| } |
| } |
| const char *s = (const char *)converted; |
| for ( u = 0; u < len; u++ ) { |
| appendOctet( (unsigned char)(s[u]) ); |
| } |
| |
| } else { |
| |
| // Encode the text using the 16-bit UCS2 alphabet. |
| if ( len > 70 ) |
| len = 70; |
| if (!implicitLength) |
| appendOctet( len * 2 + headerLen ); |
| if ( headerLen > 0 ) { |
| appendOctet( headerLen - 1 ); |
| for ( u = 0; u < headerLen - 1; u++ ) { |
| appendOctet( headers[u] ); |
| } |
| } |
| for ( u = 0; u < len; u++ ) { |
| appendOctet( (unsigned char)(txt[u].unicode() >> 8) ); |
| appendOctet( (unsigned char)(txt[u].unicode() & 0xFF) ); |
| } |
| |
| } |
| } |
| |
| // Determine if the headers in an SMS frame indicate that it |
| // is an application datagram destinated for a particular port. |
| static bool isSMSDatagram( const QByteArray& headers ) |
| { |
| uint posn = 0; |
| uint tag, len; |
| while ( ( posn + 2 ) <= (uint)(headers.size()) ) { |
| tag = (unsigned char)(headers[posn]); |
| len = (unsigned char)(headers[posn + 1]); |
| if ( ( posn + len + 2 ) > (uint)(headers.size()) ) |
| break; |
| if ( tag == (uint)SMS_HK_AppPort_8Bit || |
| tag == (uint)SMS_HK_AppPort_16Bit ) { |
| return true; |
| } |
| posn += len + 2; |
| } |
| return false; |
| } |
| |
| QString QPDUMessage::userData(QSMSDataCodingScheme scheme, QTextCodec *codec, QByteArray *& headers, bool hasHeaders, bool implicitLength) |
| { |
| QString str = ""; |
| uint len, headerLen; |
| uint u; |
| uint ch; |
| |
| // Reset the header return. |
| headers = 0; |
| |
| // Get the length of the user data payload. |
| if ( implicitLength ) { |
| len = mBuffer.size() - mPosn; |
| } else { |
| if ( !needOctets(1) ) |
| return str; |
| len = (uint)getOctet(); |
| } |
| |
| // Strip off everything except the alphabet bits. |
| scheme = (QSMSDataCodingScheme)(scheme & 0x0C); |
| |
| if ( scheme == QSMS_DefaultAlphabet ) { |
| |
| // Process a sequence in the default 7-bit GSM character set. |
| int bitCount = 0; |
| int startBit = 0; |
| ch = 0; |
| if ( implicitLength ) |
| len = len * 8 / 7; // Convert 8-bit bytes to 7-bit characters. |
| if ( hasHeaders ) { |
| u = ( len * 7 + 7 ) / 8; |
| if ( !u || !needOctets(u) ) |
| return str; |
| headerLen = getOctet(); |
| if ( headerLen >= u ) |
| return str; |
| headers = new QByteArray( getOctets( headerLen ) ); |
| if ( isSMSDatagram( *headers ) ) |
| return str; |
| u = ((headerLen + 1) * 8 + 6) / 7; |
| len -= u; |
| startBit = (headerLen + 1) * 8; |
| if ((startBit % 7) != 0) |
| startBit = 7 - (startBit % 7); |
| else |
| startBit = 0; |
| } |
| bool prefixed = false; |
| while ( len > 0 ) { |
| if ( !needOctets(1) ) |
| return str; |
| for ( int i = startBit; len > 0 && i < 8; i++ ) { |
| // test the bit and shift it down again, as i doesn't mark |
| // where we are in the current char, but bitCount does |
| ch |= ( ( peekOctet() & (Unit << i) ) >> i) << bitCount; |
| bitCount++; |
| if ( bitCount == 7 ) { |
| bitCount = 0; |
| if ( ch == 0x1B ) { // Start of a two-byte encoding. |
| prefixed = true; |
| } else if ( prefixed ) { |
| str += QChar |
| ( QGsmCodec::twoByteToUnicode( 0x1B00 | ch ) ); |
| prefixed = false; |
| } else { |
| str += QGsmCodec::singleToUnicode( (unsigned char)ch ); |
| } |
| ch = 0; |
| --len; |
| } |
| } |
| startBit = 0; |
| skipOctet(); |
| } |
| |
| } else if ( scheme == QSMS_8BitAlphabet && codec ) { |
| |
| // Process an 8-bit sequence using the supplied codec. |
| if ( !needOctets(len) ) { |
| abort(); |
| return str; |
| } |
| if ( hasHeaders ) { |
| if ( !len || len < (uint)( (peekOctet() & 0xFF) + 1 ) ) { |
| abort(); |
| return str; |
| } |
| headerLen = getOctet(); |
| headers = new QByteArray( getOctets( headerLen ) ); |
| if ( isSMSDatagram( *headers ) ) |
| return str; |
| len -= headerLen + 1; |
| } |
| str = codec->toUnicode( getOctets( len ) ); |
| |
| } else if ( scheme == QSMS_UCS2Alphabet ) { |
| |
| // Process a UCS2 sequence. |
| if ( !needOctets(len) ) { |
| abort(); |
| return str; |
| } |
| if ( hasHeaders ) { |
| if ( !len || len < (uint)( (peekOctet() & 0xFF) + 1 ) ) { |
| abort(); |
| return str; |
| } |
| headerLen = getOctet(); |
| headers = new QByteArray( getOctets( headerLen ) ); |
| len -= headerLen + 1; |
| } |
| len /= 2; |
| for ( u = 0; u < len; ++u ) { |
| ch = (((uint)(getOctet() & 0xFF)) << 8); |
| ch |= ((uint)(getOctet() & 0xFF)); |
| str += (QChar)ch; |
| } |
| |
| } else { |
| |
| // Assume 8-bit for any other coding scheme value. |
| |
| // Process an 8-bit sequence using the default Latin1 codec. |
| if ( len > (uint)(mBuffer.size() - mPosn) ) { |
| // The length field is invalid - use the actual size. |
| len = mBuffer.size() - mPosn; |
| } |
| if ( hasHeaders ) { |
| if ( !len || len < (uint)( (peekOctet() & 0xFF) + 1 ) ) { |
| abort(); |
| return str; |
| } |
| headerLen = getOctet(); |
| headers = new QByteArray( getOctets( headerLen ) ); |
| if ( isSMSDatagram( *headers ) ) |
| return str; |
| len -= headerLen + 1; |
| } |
| for ( u = 0; u < len; ++u ) { |
| str += (QChar)(getOctet() & 0xFF); |
| } |
| |
| } |
| |
| return str; |
| } |
| |
| /* Note that the meaning of messageType is also dependant on |
| the direction of the message (orig. location) */ |
| SMSMessageType QPDUMessage::messageType() |
| { |
| if ( mBuffer.size() >= 1 && |
| mBuffer.size() >= ((mBuffer[0] & 0xFF) + 2) ) { |
| |
| const char *ptr = mBuffer.constData(); |
| ptr += (*ptr & 0xFF) + 1; |
| unsigned char c = *ptr & 3; |
| return (SMSMessageType) c; |
| |
| } |
| return (SMSMessageType)0; |
| } |
| |
| QSMSSubmitMessage::QSMSSubmitMessage(const QSMSMessage &m, bool isDeliver) |
| : QPDUMessage() |
| { |
| // Clear the pdu before we start. |
| mBuffer = QByteArray(); |
| mPosn = 0; |
| mBits = 0; |
| |
| setAddress( m.serviceCenter(), true ); |
| |
| // If there is port and application data information, then |
| // create header parts for them. This is for sending datagram |
| // based messages. |
| QByteArray headers = m.headers(); |
| QSMSDataCodingScheme scheme = m.bestScheme(); |
| int part = m.findPart( "application/x-qtopia-wdp-ports" ); |
| if ( part != -1 ) { |
| QByteArray portData = m.parts()[(uint)part].data(); |
| uint size = headers.size(); |
| headers.resize(size + portData.size() + 2); |
| if ( portData.size() == 4 ) { |
| headers[size++] = (char)SMS_HK_AppPort_16Bit; |
| } else { |
| headers[size++] = (char)SMS_HK_AppPort_8Bit; |
| } |
| headers[size++] = (char)(portData.size()); |
| memcpy(headers.data() + size, portData.data(), portData.size()); |
| int dataScheme = m.dataCodingScheme(); // User-supplied override. |
| if ( dataScheme == -1 ) |
| dataScheme = 0xF5; // Special value for datagrams. |
| scheme = (QSMSDataCodingScheme)dataScheme; |
| } else if ( m.messageClass() != -1 ) { |
| scheme = (QSMSDataCodingScheme) |
| (scheme | QSMS_MessageClass | m.messageClass()); |
| int dataScheme = m.dataCodingScheme(); // User-supplied override. |
| if ( dataScheme != -1 ) |
| scheme = (QSMSDataCodingScheme)dataScheme; |
| } else { |
| int dataScheme = m.dataCodingScheme(); // User-supplied override. |
| if ( dataScheme != -1 ) |
| scheme = (QSMSDataCodingScheme)dataScheme; |
| } |
| |
| if ( !isDeliver ) |
| setBits(0, 2, SMS_Submit); |
| else |
| setBits(0, 2, SMS_Deliver); |
| |
| setBit(2, false); // TP-Reject-Duplicates |
| if ( !isDeliver && m.validityPeriod() == (uint)(-1) ) |
| setBits(3, 2, SMS_VF_NoPresent); |
| else |
| setBits(3, 2, SMS_VF_Relative); |
| setBit(5, m.statusReportRequested());// TP-Status-Report-Requested; |
| setBit(6, headers.size() != 0); // TP-User-Data Header |
| setBit(7, m.replyRequest()); // TP-Reply-Path |
| |
| commitBits(); // first octet done |
| |
| //second octet TP-MR (Message reference |
| if( !isDeliver ) |
| appendOctet(0); |
| |
| if ( !isDeliver ) { |
| //third octet TP-DA (Destination Address) |
| //len must be done later |
| setAddress( m.recipient(), false ); |
| } else { |
| setAddress( m.sender(), false); |
| } |
| |
| |
| //nth octet, TP-PID (protocol identifier) |
| if ( !isDeliver ) |
| appendOctet(m.protocol()); |
| else |
| appendOctet(1); //arbitrary protocol for deliver |
| |
| // TP-DCS ( Data coding scheme ) |
| appendOctet(scheme); |
| |
| if ( !isDeliver ) { |
| // TP-VP ( Validity Period ) |
| if ( m.validityPeriod() != (uint)(-1) ) |
| appendOctet(m.gsmValidityPeriod()); |
| } else { |
| setTimeStamp(m.timestamp()); |
| } |
| |
| // Set the user data field. |
| if ( part == -1 ) { |
| setUserData(m.text(), scheme, m.textCodec(), headers); |
| } else { |
| // The applicationData() is the text to be sent in the datagram. |
| QByteArray appData = m.applicationData(); |
| uint len = appData.size(); |
| if ( ( len + headers.size() + 1 ) > 140 ) |
| len = 140 - headers.size() - 1; |
| appendOctet( len + headers.size() + 1 ); |
| appendOctet( headers.size() ); |
| uint u; |
| for ( u = 0; u < (uint)headers.size(); u++ ) { |
| appendOctet( headers[u] ); |
| } |
| for ( u = 0; u < len; u++ ) { |
| appendOctet( appData[u] ); |
| } |
| } |
| } |
| |
| QSMSDeliverMessage::QSMSDeliverMessage(const QByteArray &pdu) |
| : QPDUMessage(pdu) |
| { |
| } |
| |
| // Unpack a message that has a "//SCKL" header in its text body. |
| // This is a standard to interoperate with networks and phones |
| // that do not support user data headers properly. |
| static void unpackSckl( QSMSMessage& m, const QString& text ) |
| { |
| // Split into header and body, separated by a space. |
| int index = text.indexOf( QChar(' ') ); |
| if ( index == -1 ) { |
| m.addPart( QSMSMessagePart( text ) ); |
| return; |
| } |
| QString head = text.mid( 6, index - 6 ); |
| QString body = text.mid( index + 1 ); |
| |
| // Convert the header from hex into raw binary and then |
| // copy its details into the real message header fields. |
| QByteArray header = QAtUtils::fromHex( head ); |
| int len; |
| if ( header.size() < 4 ) { |
| len = header.size(); |
| } else { |
| len = 4; |
| } |
| QByteArray ports( len, '\0' ); |
| memcpy( ports.data(), header.data(), len ); |
| m.addPart( QSMSMessagePart( "application/x-qtopia-wdp-ports", ports ) ); |
| if ( header.size() > 4 ) { |
| QByteArray fragments( header.size() - 4 + 2, '\0' ); |
| fragments[0] = (char)( SMS_HK_Concat_8Bit ); |
| fragments[1] = (char)( header.size() - 4 ); |
| memcpy( fragments.data() + 2, header.data() + 4, header.size() - 4 ); |
| m.setHeaders( fragments ); |
| } |
| |
| // Is the body text or binary? |
| int port = m.destinationPort(); |
| if ( port == 226 || port == 9204 || // vCard port numbers. |
| port == 228 || port == 9205 ) { // vCalendar port numbers. |
| m.setApplicationData( body.toLatin1() ); |
| } else { |
| m.setApplicationData( QAtUtils::fromHex( body ) ); |
| } |
| } |
| |
| QSMSMessage QSMSDeliverMessage::unpack(QTextCodec *codec) |
| { |
| QSMSMessage m; |
| bool statusReport; |
| bool userDataHeader; |
| bool replyPath; |
| unsigned char protocol; |
| unsigned char scheme; |
| uint msgType; |
| uint validityFormat; |
| |
| // Start from the beginning of the PDU. |
| reset(); |
| |
| // Extract the service center address. |
| m.setServiceCenter( address(true) ); |
| |
| // Pull apart the message header. We handle both deliver and |
| // submit messages, because we may have pulled a submit out |
| // of the phone's outgoing SMS queue. |
| if ( !needOctets(1) ) |
| return m; |
| msgType = bits(0, 2); |
| if ( msgType == SMS_Deliver ) { |
| // Bits 3 and 4 are unused for deliver messages. |
| statusReport = bit(5); |
| userDataHeader = bit(6); |
| replyPath = bit(7); |
| validityFormat = SMS_VF_NoPresent; |
| } else if ( msgType == SMS_Submit ) { |
| validityFormat = bits(3, 2); |
| statusReport = bit(5); |
| userDataHeader = bit(6); |
| replyPath = bit(7); |
| } else { |
| // Probably a delivery report, which we don't process. |
| return m; |
| } |
| skipOctet(); |
| |
| // Remember the status and reply bits. |
| m.setStatusReportRequested(statusReport); |
| m.setReplyRequest(replyPath); |
| |
| // Skip the message reference (submit messages only). |
| if ( msgType == SMS_Submit ) { |
| if ( !needOctets(1) ) |
| return m; |
| skipOctet(); |
| } |
| |
| // Get the address of the sender (delivery) or recipient (submit). |
| if ( msgType == SMS_Deliver ) { |
| m.setSender( address(false) ); |
| } else { |
| m.setRecipient( address(false) ); |
| } |
| |
| // Get the protocol identifier and data coding scheme. |
| if ( !needOctets(2) ) |
| return m; |
| protocol = getOctet(); |
| scheme = getOctet(); |
| m.setProtocol( protocol ); |
| m.setDataCodingScheme( scheme ); |
| if ( ( scheme & QSMS_MessageClass ) != 0 ) |
| m.setMessageClass( scheme & 0x03 ); |
| else |
| m.setMessageClass( -1 ); |
| |
| // Get the timestamp (deliver) or validity period (submit) information. |
| if ( msgType == SMS_Deliver ) { |
| m.setTimestamp( timeStamp() ); |
| } else { |
| if ( validityFormat == SMS_VF_Relative ) { |
| if ( !needOctets(1) ) |
| return m; |
| m.setGsmValidityPeriod( bits(0, 8) ); |
| skipOctet(); |
| } else if (validityFormat == SMS_VF_Absolute ) { |
| m.setTimestamp( timeStamp() ); |
| } else if (validityFormat == SMS_VF_Enhanced ) { |
| // Not supported yet - skip the octets. |
| if ( !needOctets(7) ) |
| return m; |
| mPosn += 7; |
| } else { |
| m.setValidityPeriod( (uint)(-1) ); |
| } |
| } |
| |
| // Read the user data field. |
| QByteArray *headers = 0; |
| QString text; |
| text = userData( (QSMSDataCodingScheme)scheme, codec, |
| headers, userDataHeader, false ); |
| if ( !headers && text.startsWith( "//SCKL" ) ) { |
| unpackSckl( m, text ); |
| return m; |
| } |
| if ( headers ) { |
| m.setHeaders( *headers ); |
| delete headers; |
| m.unpackHeaderParts(); |
| if ( isSMSDatagram( m.d->mHeaders ) && mPosn <= mBuffer.size() ) { |
| // The rest of the PDU is assumed to be the application payload. |
| QByteArray array = mBuffer.mid( mPosn ); |
| m.addPart( QSMSMessagePart( "application/x-qtopia-wdp", array ) ); |
| } |
| } |
| if ( text.length() > 0 ) { |
| m.addPart( QSMSMessagePart( text ) ); |
| } |
| |
| // Return the completed message to the caller. |
| return m; |
| } |
| |
| |
| QCBSDeliverMessage::QCBSDeliverMessage() |
| : QPDUMessage() |
| { |
| // Nothing to do here. |
| } |
| |
| |
| QCBSDeliverMessage::QCBSDeliverMessage(const QByteArray &pdu) |
| : QPDUMessage(pdu) |
| { |
| // Nothing to do here. |
| } |
| |
| |
| QCBSMessage QCBSDeliverMessage::unpack(QTextCodec *codec) |
| { |
| QCBSMessage m; |
| unsigned char scheme; |
| uint len; |
| |
| // Start from the beginning of the PDU. |
| reset(); |
| |
| // Extract the header fields. |
| if ( !needOctets(6) ) |
| return m; |
| |
| const char *mOffset = mBuffer.constData() + mPosn; |
| m.setMessageCode( ((mOffset[0] & 0xFC) << 2) | (mOffset[1] & 0x0F) ); |
| m.setScope( (QCBSMessage::GeographicalScope)(mOffset[0] & 0x03) ); |
| m.setUpdateNumber( (mOffset[1] >> 4) & 0x0F ); |
| m.setChannel( ((mOffset[2] & 0xFF) << 8) | (mOffset[3] & 0xFF) ); |
| scheme = (unsigned char)((mOffset[4] >> 4) & 0x0F); |
| m.setLanguage( (QCBSMessage::Language)(mOffset[4] & 0x0F) ); |
| m.setNumPages( (uint)((mOffset[5] >> 4) & 0x0F) ); |
| m.setPage( (uint)(mOffset[5] & 0x0F) ); |
| mPosn += 6; |
| |
| // Read the user data field and strip CR's, LF's, and NUL's from the end. |
| QByteArray *headers = 0; |
| QString text = userData |
| ( (QSMSDataCodingScheme)scheme, codec, headers, false, true ); |
| len = text.length(); |
| while ( len > 0 && ( text[len - 1] == '\r' || text[len - 1] == '\n' || |
| text[len - 1] == '\0' ) ) { |
| --len; |
| } |
| m.setText( text.left( len ) ); |
| |
| // Return the completed message to the caller. |
| return m; |
| } |
| |
| void QCBSDeliverMessage::pack(const QCBSMessage &m, QSMSDataCodingScheme scheme) |
| { |
| // Clear the pdu before we start. |
| mBuffer = QByteArray(); |
| mPosn = 0; |
| mBits = 0; |
| |
| scheme = QSMS_DefaultAlphabet; |
| QByteArray data; |
| mBuffer.append( (char) (((m.messageCode() >> 4) & 0x3F) | (m.scope() << 6)) ); |
| mBuffer.append( (char)(((m.messageCode() & 0xF) << 4) | (m.updateNumber() & 0xF)) ); |
| mBuffer.append( (char)((m.channel() & 0x0000FF00) >> 8) ); |
| mBuffer.append( (char)(m.channel() & 0x000000FF) ); |
| mBuffer.append( (char)(((scheme & 0x0F)<<4) | (m.language() & 0x0F)) ); |
| mBuffer.append( (char)((m.numPages() & 0x0F) | ((m.page() & 0x0F) << 4)) ); |
| |
| QTextCodec *codec = QAtUtils::codec( "gsm" ); |
| QByteArray header; |
| |
| QString paddedText = m.text(); |
| |
| int numPad = 93 - getEncodedLength(paddedText, paddedText.length()); |
| |
| for (int i = 0; i < numPad; i++) |
| paddedText.append(QChar(0x0D)); |
| |
| setUserData(paddedText, scheme, codec, header,true); |
| } |
