void String::SetUTF8FromWChar(const wchar_t* str)
{
char temp[7];
Clear();
if (!str)
return;
#ifdef _WIN32
while (*str)
{
unsigned unicodeChar = DecodeUTF16(str);
char* dest = temp;
EncodeUTF8(dest, unicodeChar);
*dest = 0;
Append(temp);
}
#else
while (*str)
{
char* dest = temp;
EncodeUTF8(dest, (unsigned)*str++);
*dest = 0;
Append(temp);
}
#endif
}
String& String::AppendUTF8(unsigned unicodeChar)
{
char temp[7];
char* dest = temp;
EncodeUTF8(dest, unicodeChar);
*dest = 0;
return Append(temp);
}
static void SaveLDIFText(FILE *file, const char *Name, const unsigned char *Value)
{
unsigned char Buffer[1000],Buffer2[1000];
if (EncodeUTF8(Buffer, Value)) {
EncodeBASE64(Buffer, Buffer2, strlen(Buffer));
fprintf(file,"%s:: %s%c%c",Name,Buffer2,13,10);
} else {
fprintf(file,"%s: %s%c%c",Name,DecodeUnicodeString(Value),13,10);
}
}
void String::SetUTF8FromLatin1(const char* str)
{
char temp[7];
Clear();
if (!str)
return;
while (*str)
{
char* dest = temp;
EncodeUTF8(dest, (unsigned)*str++);
*dest = 0;
Append(temp);
}
}
bool CUniString::TokenizeAsciiEscapedUnicode()
{
CUString tmp = GetStr();
while( true ) {
int idx = tmp.Find( "\\u" );
if( idx < 0 ) {
for( int i=0; i<tmp.GetLength(); i++ ) {
char ch = tmp.GetAt(i);
if( (int)ch >= 0 ) {
char buf[4]; sprintf( buf, "%c", ch );
unichar_list.PushBack( buf );
enc_byte += 1;
}
else {
return false;
}
}
break;
}
else {
for( int i=0; i<idx; i++ ) {
char ch = tmp.GetAt(i);
if( (int)ch >= 0 ) {
char buf[4]; sprintf( buf, "%c", ch );
unichar_list.PushBack( buf );
enc_byte += 1;
}
else {
return false;
}
}
CUString uni = tmp.SubStr( idx, idx+6 );
uni = EncodeUTF8( uni );
unichar_list.PushBack( uni );
enc_byte += uni.GetLength();
tmp = tmp.Mid( idx+6 );
}
}
return true;
}
void String::ReplaceUTF8(unsigned index, unsigned unicodeChar)
{
unsigned utfPos = 0;
unsigned byteOffset = 0;
while (utfPos < index && byteOffset < length_)
{
NextUTF8Char(byteOffset);
++utfPos;
}
if (utfPos < index)
return;
unsigned beginCharPos = byteOffset;
NextUTF8Char(byteOffset);
char temp[7];
char* dest = temp;
EncodeUTF8(dest, unicodeChar);
*dest = 0;
Replace(beginCharPos, byteOffset - beginCharPos, temp, (unsigned)(dest - temp));
}
void String::ReplaceUTF8(size_t index, unsigned unicodeChar)
{
size_t utfPos = 0;
size_t byteOffset = 0;
while (utfPos < index && byteOffset < Length())
{
NextUTF8Char(byteOffset);
++utfPos;
}
if (utfPos < index)
return;
size_t beginCharPos = byteOffset;
NextUTF8Char(byteOffset);
char temp[7];
char* dest = temp;
EncodeUTF8(dest, unicodeChar);
*dest = 0;
Replace(beginCharPos, byteOffset - beginCharPos, temp, dest - temp);
}
/* Save SMS from phone (called Inbox sms - it's in phone Inbox) somewhere */
static GSM_Error SMSDSQL_SaveInboxSMS(GSM_MultiSMSMessage * sms, GSM_SMSDConfig * Config, char **Locations)
{
SQL_result res, res2;
SQL_Var vars[3];
struct GSM_SMSDdbobj *db = Config->db;
const char *q, *status;
char smstext[3 * GSM_MAX_SMS_LENGTH + 1];
char destinationnumber[3 * GSM_MAX_NUMBER_LENGTH + 1];
char smsc_message[3 * GSM_MAX_NUMBER_LENGTH + 1];
int i;
time_t t_time1, t_time2;
gboolean found;
long diff;
unsigned long long new_id;
size_t locations_size = 0, locations_pos = 0;
const char *state, *smsc;
*Locations = NULL;
for (i = 0; i < sms->Number; i++) {
EncodeUTF8(destinationnumber, sms->SMS[i].Number);
EncodeUTF8(smsc_message, sms->SMS[i].SMSC.Number);
if (sms->SMS[i].PDU == SMS_Status_Report) {
EncodeUTF8(smstext, sms->SMS[i].Text);
SMSD_Log(DEBUG_INFO, Config, "Delivery report: %s to %s", smstext, destinationnumber);
if (SMSDSQL_NamedQuery(Config, Config->SMSDSQL_queries[SQL_QUERY_SAVE_INBOX_SMS_SELECT], &sms->SMS[i], NULL, &res) != SQL_OK) {
SMSD_Log(DEBUG_INFO, Config, "Error reading from database (%s)", __FUNCTION__);
return ERR_UNKNOWN;
}
found = FALSE;
while (db->NextRow(Config, &res)) {
smsc = db->GetString(Config, &res, 4);
state = db->GetString(Config, &res, 1);
SMSD_Log(DEBUG_NOTICE, Config, "Checking for delivery report, SMSC=%s, state=%s", smsc, state);
if (strcmp(smsc, smsc_message) != 0) {
if (Config->skipsmscnumber[0] == 0 || strcmp(Config->skipsmscnumber, smsc)) {
continue;
}
}
if (strcmp(state, "SendingOK") == 0 || strcmp(state, "DeliveryPending") == 0) {
t_time1 = db->GetDate(Config, &res, 2);
if (t_time1 < 0) {
SMSD_Log(DEBUG_ERROR, Config, "Invalid SendingDateTime -1 for SMS TPMR=%i", sms->SMS[i].MessageReference);
return ERR_UNKNOWN;
}
t_time2 = Fill_Time_T(sms->SMS[i].DateTime);
diff = t_time2 - t_time1;
if (diff > -Config->deliveryreportdelay && diff < Config->deliveryreportdelay) {
found = TRUE;
break;
} else {
SMSD_Log(DEBUG_NOTICE, Config,
"Delivery report would match, but time delta is too big (%ld), consider increasing DeliveryReportDelay", diff);
}
}
}
if (found) {
if (!strcmp(smstext, "Delivered")) {
q = Config->SMSDSQL_queries[SQL_QUERY_SAVE_INBOX_SMS_UPDATE_DELIVERED];
} else {
q = Config->SMSDSQL_queries[SQL_QUERY_SAVE_INBOX_SMS_UPDATE];
}
if (!strcmp(smstext, "Delivered")) {
status = "DeliveryOK";
} else if (!strcmp(smstext, "Failed")) {
status = "DeliveryFailed";
} else if (!strcmp(smstext, "Pending")) {
status = "DeliveryPending";
} else if (!strcmp(smstext, "Unknown")) {
status = "DeliveryUnknown";
} else {
status = "";
}
vars[0].type = SQL_TYPE_STRING;
vars[0].v.s = status; /* Status */
vars[1].type = SQL_TYPE_INT;
vars[1].v.i = (long)db->GetNumber(Config, &res, 0); /* ID */
vars[2].type = SQL_TYPE_NONE;
if (SMSDSQL_NamedQuery(Config, q, &sms->SMS[i], vars, &res2) != SQL_OK) {
SMSD_Log(DEBUG_INFO, Config, "Error writing to database (%s)", __FUNCTION__);
return ERR_UNKNOWN;
}
db->FreeResult(Config, &res2);
}
db->FreeResult(Config, &res);
continue;
}
if (sms->SMS[i].PDU != SMS_Deliver)
continue;
if (SMSDSQL_NamedQuery(Config, Config->SMSDSQL_queries[SQL_QUERY_SAVE_INBOX_SMS_INSERT], &sms->SMS[i], NULL, &res) != SQL_OK) {
SMSD_Log(DEBUG_INFO, Config, "Error writing to database (%s)", __FUNCTION__);
return ERR_UNKNOWN;
}
new_id = db->SeqID(Config, "inbox_ID_seq");
if (new_id == 0) {
SMSD_Log(DEBUG_INFO, Config, "Failed to get inserted row ID (%s)", __FUNCTION__);
return ERR_UNKNOWN;
}
SMSD_Log(DEBUG_NOTICE, Config, "Inserted message id %lu", (long)new_id);
db->FreeResult(Config, &res);
if (new_id != 0) {
if (locations_pos + 10 >= locations_size) {
locations_size += 40;
*Locations = (char *)realloc(*Locations, locations_size);
assert(*Locations != NULL);
if (locations_pos == 0) {
*Locations[0] = 0;
}
}
locations_pos += sprintf((*Locations) + locations_pos, "%lu ", (long)new_id);
}
if (SMSDSQL_NamedQuery(Config, Config->SMSDSQL_queries[SQL_QUERY_UPDATE_RECEIVED], &sms->SMS[i], NULL, &res2) != SQL_OK) {
SMSD_Log(DEBUG_INFO, Config, "Error updating number of received messages (%s)", __FUNCTION__);
return ERR_UNKNOWN;
}
db->FreeResult(Config, &res2);
}
return ERR_NONE;
}
static SQL_Error SMSDSQL_NamedQuery(GSM_SMSDConfig * Config, const char *sql_query, GSM_SMSMessage *sms,
const SQL_Var *params, SQL_result * res)
{
char buff[65536], *ptr, c, static_buff[8192];
char *buffer2, *end;
const char *to_print, *q = sql_query;
int int_to_print;
int numeric;
int n, argc = 0;
struct GSM_SMSDdbobj *db = Config->db;
if (params != NULL) {
while (params[argc].type != SQL_TYPE_NONE) argc++;
}
ptr = buff;
do {
if (*q != '%') {
*ptr++ = *q;
continue;
}
c = *(++q);
if( c >= '0' && c <= '9'){
n = strtoul(q, &end, 10) - 1;
if (n < argc && n >= 0) {
switch(params[n].type){
case SQL_TYPE_INT:
ptr += sprintf(ptr, "%i", params[n].v.i);
break;
case SQL_TYPE_STRING:
buffer2 = db->QuoteString(Config, params[n].v.s);
memcpy(ptr, buffer2, strlen(buffer2));
ptr += strlen(buffer2);
free(buffer2);
break;
default:
SMSD_Log(DEBUG_ERROR, Config, "SQL: unknown type: %i (application bug) in query: `%s`", params[n].type, sql_query);
return SQL_BUG;
break;
}
} else {
SMSD_Log(DEBUG_ERROR, Config, "SQL: wrong number of parameter: %i (max %i) in query: `%s`", n+1, argc, sql_query);
return SQL_BUG;
}
q = end - 1;
continue;
}
numeric = 0;
to_print = NULL;
switch (c) {
case 'I':
to_print = Config->Status->IMEI;
break;
case 'P':
to_print = Config->PhoneID;
break;
case 'N':
snprintf(static_buff, sizeof(static_buff), "Gammu %s, %s, %s", GAMMU_VERSION, GetOS(), GetCompiler());
to_print = static_buff;
break;
case 'A':
to_print = Config->CreatorID;
break;
default:
if (sms != NULL) {
switch (c) {
case 'R':
EncodeUTF8(static_buff, sms->Number);
to_print = static_buff;
break;
case 'F':
EncodeUTF8(static_buff, sms->SMSC.Number);
to_print = static_buff;
break;
case 'u':
if (sms->UDH.Type != UDH_NoUDH) {
EncodeHexBin(static_buff, sms->UDH.Text, sms->UDH.Length);
to_print = static_buff;
}else{
to_print = "";
}
break;
case 'x':
int_to_print = sms->Class;
numeric = 1;
break;
case 'c':
to_print = GSM_SMSCodingToString(sms->Coding);
break;
case 't':
int_to_print = sms->MessageReference;
numeric = 1;
break;
case 'E':
switch (sms->Coding) {
case SMS_Coding_Unicode_No_Compression:
case SMS_Coding_Default_No_Compression:
EncodeHexUnicode(static_buff, sms->Text, UnicodeLength(sms->Text));
break;
case SMS_Coding_8bit:
EncodeHexBin(static_buff, sms->Text, sms->Length);
break;
default:
*static_buff = '\0';
break;
}
to_print = static_buff;
break;
case 'T':
switch (sms->Coding) {
case SMS_Coding_Unicode_No_Compression:
case SMS_Coding_Default_No_Compression:
EncodeUTF8(static_buff, sms->Text);
to_print = static_buff;
break;
default:
to_print = "";
break;
}
break;
case 'V':
if (sms->SMSC.Validity.Format == SMS_Validity_RelativeFormat) {
int_to_print = sms->SMSC.Validity.Relative;
} else {
int_to_print = -1;
}
numeric = 1;
break;
case 'C':
SMSDSQL_Time2String(Config, Fill_Time_T(sms->SMSCTime), static_buff, sizeof(static_buff));
to_print = static_buff;
break;
case 'd':
SMSDSQL_Time2String(Config, Fill_Time_T(sms->DateTime), static_buff, sizeof(static_buff));
to_print = static_buff;
break;
case 'e':
int_to_print = sms->DeliveryStatus;
numeric = 1;
break;
default:
SMSD_Log(DEBUG_ERROR, Config, "SQL: uexpected char '%c' in query: %s", c, sql_query);
return SQL_BUG;
} /* end of switch */
} else {
SMSD_Log(DEBUG_ERROR, Config, "Syntax error in query.. uexpected char '%c' in query: %s", c, sql_query);
return SQL_BUG;
}
break;
} /* end of switch */
if (numeric) {
ptr += sprintf(ptr, "%i", int_to_print);
} else if (to_print != NULL) {
buffer2 = db->QuoteString(Config, to_print);
memcpy(ptr, buffer2, strlen(buffer2));
ptr += strlen(buffer2);
free(buffer2);
} else {
memcpy(ptr, "NULL", 4);
ptr += 4;
}
} while (*(++q) != '\0');
*ptr = '\0';
return SMSDSQL_Query(Config, buff, res);
}
test_result(out[1] == 0x82);
test_result(out[2] == 0xac);
test_result(EncodeWithUTF8Alphabet(0x10348, out) == 4);
test_result(out[0] == 0xf0);
test_result(out[1] == 0x90);
test_result(out[2] == 0x8d);
test_result(out[3] == 0x88);
test_result(EncodeWithUTF8Alphabet(0x1F44D, out) == 4);
test_result(out[0] == 0xf0);
test_result(out[1] == 0x9f);
test_result(out[2] == 0x91);
test_result(out[3] == 0x8d);
test_result(EncodeUTF8(out, "\xD8\x3d\xDC\x4d\x00\x00"));
test_result(out[0] == 0xf0);
test_result(out[1] == 0x9f);
test_result(out[2] == 0x91);
test_result(out[3] == 0x8d);
test_result(out[4] == 0x00);
test_result(DecodeWithUTF8Alphabet("\xf0\x9f\x91\x8d\x00", &dest, 4) == 4);
test_result(dest == 0x1f44d);
DecodeUTF8(out, "\xf0\x9f\x91\x8d\x00", 4);
test_string("\xD8\x3d\xDC\x4d\x00", out, 5);
DecodeUTF8(out, "ahoj", 4);
