gsmmisc.c File Reference

#include <gammu-config.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <gammu-keys.h>
#include <gammu-debug.h>
#include "../misc/coding/coding.h"
#include "../debug.h"
#include "gsmmisc.h"
#include "../../helper/string.h"

Include dependency graph for gsmmisc.c:

Go to the source code of this file.

Data Structures
struct	keys_table_position

Functions
GSM_Error	MakeKeySequence (char *text, GSM_KeyCode *KeyCode, size_t *Length)
GSM_Error	GSM_ReadFile (const char *FileName, GSM_File *File)
static void	GSM_JADFindLine (GSM_File *File, const char *Name, char *Value)
GSM_Error	GSM_JADFindData (GSM_File *File, char *Vendor, char *Name, char *JAR, char *Version, int *Size)
void	GSM_IdentifyFileFormat (GSM_File *File)
GSM_Error	VC_StoreLine (char *Buffer, const size_t buff_len, size_t *Pos, const char *format,...)
GSM_Error	VC_Store (char *Buffer, const size_t buff_len, size_t *Pos, const char *format,...)
GSM_Error	VC_StoreDateTime (char *Buffer, const size_t buff_len, size_t *Pos, const GSM_DateTime *Date, const char *Start)
GSM_Error	VC_StoreDate (char *Buffer, const size_t buff_len, size_t *Pos, const GSM_DateTime *Date, const char *Start)
gboolean	ReadVCALDateTime (const char *Buffer, GSM_DateTime *dt)
gboolean	ReadVCALInt (char *Buffer, const char *Start, int *Value)
gboolean	ReadVCALDate (char *Buffer, const char *Start, GSM_DateTime *Date, gboolean *is_date_only)
GSM_Error	VC_StoreText (char *Buffer, const size_t buff_len, size_t *Pos, const unsigned char *Text, const char *Start, const gboolean UTF8)
GSM_Error	VC_StoreBase64 (char *Buffer, const size_t buff_len, size_t *Pos, const unsigned char *data, const size_t length)
unsigned char *	VCALGetTextPart (unsigned char *Buff, int *pos)
gboolean	ReadVCALText (char *Buffer, const char *Start, unsigned char *Value, const gboolean UTF8, GSM_EntryLocation *location)
void	GSM_ClearBatteryCharge (GSM_BatteryCharge *bat)

Variables
static struct keys_table_position	Keys []

Function Documentation

GSM_ClearBatteryCharge()

void GSM_ClearBatteryCharge

(

GSM_BatteryCharge *

bat

)

Resets all members of GSM_BatteryCharge structure.

Definition at line 784 of file gsmmisc.c.

References GSM_BatteryCharge::BatteryCapacity, GSM_BatteryCharge::BatteryPercent, GSM_BatteryCharge::BatteryTemperature, GSM_BatteryCharge::BatteryType, GSM_BatteryCharge::BatteryVoltage, GSM_BatteryCharge::ChargeCurrent, GSM_BatteryCharge::ChargeState, GSM_BatteryCharge::ChargeVoltage, GSM_BatteryCharge::PhoneCurrent, and GSM_BatteryCharge::PhoneTemperature.

{
    bat->BatteryPercent = -1;
    bat->ChargeState = 0;
    bat->BatteryType = 0;
    bat->BatteryVoltage = -1;
    bat->ChargeVoltage = -1;
    bat->ChargeCurrent = -1;
    bat->PhoneCurrent = -1;
    bat->BatteryTemperature = -1;
    bat->PhoneTemperature = -1;
    bat->BatteryCapacity = -1;
}

GSM_JADFindLine()

static void GSM_JADFindLine ( GSM_File *  File, const char *  Name, char *  Value  )

static

Definition at line 117 of file gsmmisc.c.

References GSM_File::Buffer, ERR_NONE, FALSE, MyGetLine(), and GSM_File::Used.

Referenced by GSM_JADFindData().

{
        unsigned char   Line[2000];
        size_t          Pos = 0;

        Value[0] = 0;

        while (1) {
                if (MyGetLine(File->Buffer, &Pos, Line, File->Used, sizeof(Line), FALSE) != ERR_NONE) break;
                if (strlen(Line) == 0) break;
                if (!strncmp(Line,Name,strlen(Name))) {
                        Pos = strlen(Name);
                        while (Line[Pos] == 0x20) Pos++;
                        strcpy(Value,Line+Pos);
                        return;
                }
        }
}

ReadVCALDate()

gboolean ReadVCALDate	(	char *	Buffer,
		const char *	Start,
		GSM_DateTime *	Date,
		gboolean *	is_date_only
	)

Definition at line 335 of file gsmmisc.c.

References dbgprintf, DecodeUnicodeString(), FALSE, OSDate(), ReadVCALDateTime(), ReadVCALText(), and TRUE.

Referenced by GSM_DecodeVCALENDAR_VTODO().

{
        char fullstart[200];
        unsigned char datestring[200];

        if (!ReadVCALText(Buffer, Start, datestring, FALSE, NULL)) {
                fullstart[0] = 0;
                strcat(fullstart, Start);
                strcat(fullstart, ";VALUE=DATE");
                if (!ReadVCALText(Buffer, fullstart, datestring, FALSE, NULL)) {
                        return FALSE;
                }
                *is_date_only = TRUE;
        }

        if (ReadVCALDateTime(DecodeUnicodeString(datestring), Date)) {
                dbgprintf(NULL, "ReadVCALDateTime is %s\n", OSDate(*Date));
                *is_date_only = FALSE;
                return TRUE;
        }

        return FALSE;
}

ReadVCALDateTime()

gboolean ReadVCALDateTime	(	const char *	Buffer,
		GSM_DateTime *	dt
	)

Todo:

Handle properly timezone information

Definition at line 254 of file gsmmisc.c.

References CheckDate(), CheckTime(), GSM_DateTime::Day, dbgprintf, FALSE, Fill_GSM_DateTime(), Fill_Time_T(), GSM_DateTime::Hour, GSM_DateTime::Minute, GSM_DateTime::Month, GSM_DateTime::Second, GSM_DateTime::Timezone, TRUE, and GSM_DateTime::Year.

Referenced by GSM_DecodeVCAL_RRULE(), GSM_DecodeVCARD(), and ReadVCALDate().

{
        time_t timestamp;
        char year[5]="", month[3]="", day[3]="", hour[3]="", minute[3]="", second[3]="";

        memset(dt,0,sizeof(GSM_DateTime));

        /* YYYY-MM-DD is invalid, though used */
        if (sscanf(Buffer, "%d-%d-%d", &dt->Year, &dt->Month, &dt->Day) == 3) {
                goto checkdt;
        }

        if (strlen(Buffer) < 8) {
                return FALSE;
        }

        strncpy(year,   Buffer,         4);
        strncpy(month,  Buffer+4,       2);
        strncpy(day,    Buffer+6,       2);
        dt->Year        = atoi(year);
        dt->Month       = atoi(month);
        dt->Day         = atoi(day);

        if (Buffer[8] == 'T') {
                if (strlen(Buffer + 9) < 6) return FALSE;

                strncpy(hour,   Buffer+9,       2);
                strncpy(minute, Buffer+11,      2);
                strncpy(second, Buffer+13,      2);
                dt->Hour        = atoi(hour);
                dt->Minute      = atoi(minute);
                dt->Second      = atoi(second);

                if (Buffer[15] == 'Z') dt->Timezone = 0; /* Z = ZULU = GMT */
        }
checkdt:

        if (!CheckTime(dt)) {
                dbgprintf(NULL, "incorrect date %d-%d-%d %d:%d:%d\n",dt->Day,dt->Month,dt->Year,dt->Hour,dt->Minute,dt->Second);
                return FALSE;
        }
        if (dt->Year!=0) {
                if (!CheckDate(dt)) {
                        dbgprintf(NULL, "incorrect date %d-%d-%d %d:%d:%d\n",dt->Day,dt->Month,dt->Year,dt->Hour,dt->Minute,dt->Second);
                        return FALSE;
                }
        }

        if (dt->Timezone != 0) {
                timestamp = Fill_Time_T(*dt) + dt->Timezone;
                Fill_GSM_DateTime(dt, timestamp);
        }

        return TRUE;
}

ReadVCALInt()

gboolean ReadVCALInt	(	char *	Buffer,
		const char *	Start,
		int *	Value
	)

Definition at line 313 of file gsmmisc.c.

References dbgprintf, FALSE, and TRUE.

Referenced by GSM_DecodeVCALENDAR_VTODO().

{
        unsigned char buff[200];

        *Value = 0;

        strcpy(buff,Start);
        strcat(buff,":");
        if (!strncmp(Buffer,buff,strlen(buff))) {
                int lstart = strlen(Start);
                int lvalue = strlen(Buffer)-(lstart+1);
                strncpy(buff,Buffer+lstart+1,lvalue);
                strncpy(buff+lvalue,"\0",1);
                if (sscanf(buff,"%i",Value)) {
                        dbgprintf(NULL, "ReadVCalInt is \"%i\"\n",*Value);
                        return TRUE;
                }
        }
        return FALSE;
}

ReadVCALText()

gboolean ReadVCALText	(	char *	Buffer,
		const char *	Start,
		unsigned char *	Value,
		const gboolean	UTF8,
		GSM_EntryLocation *	location
	)

We separate matching text (Start) to tokens and then try to find all tokens in Buffer. We also accept tokens like PREF, CHARSET or ENCODING.

Also it parses TYPE=* tokens, matching it to text types passed in Start parameter. For example Start "TEL;FAX;VOICE" matches "TEL;TYPE=FAX,VOICE" or "TEL;FAX;TYPE=VOICE" or "TEL;TYPE=FAX;TYPE=VOICE" and of course "TEL;FAX;VOICE".

When all tokens are matched we found matching line.

Definition at line 468 of file gsmmisc.c.

References dbgprintf, DecodeISO88591(), DecodeISO88591QuotedPrintable(), DecodeUnicodeConsole(), DecodeUTF7(), DecodeUTF8(), DecodeUTF8QuotedPrintable(), FALSE, PBK_Location_Home, PBK_Location_Unknown, PBK_Location_Work, TRUE, and UnicodeLength().

Referenced by GSM_DecodeVCALENDAR_VTODO(), GSM_DecodeVCARD(), GSM_DecodeVNOTE(), and ReadVCALDate().

{
        char *line = NULL;
        char **tokens = NULL;
        char *charset = NULL;
        char *begin, *pos, *end, *end2;
        gboolean quoted_printable = FALSE;
        size_t numtokens, token;
        size_t i, j, len;
        gboolean found;
        gboolean ret = FALSE;

        /* Initialize output */
        Value[0] = 0x00;
        Value[1] = 0x00;

        /* Count number of tokens */
        len = strlen(Start);
        numtokens = 1;
        for (i = 0; i < len; i++) {
                if (Start[i] == ';') {
                        numtokens++;
                }
        }

        /* Allocate memory */
        line = strdup(Start);
        if (line == NULL) {
                dbgprintf(NULL, "Could not alloc!\n");
                goto fail;
        }
        tokens = (char **)malloc(sizeof(char *) * numtokens);
        if (tokens == NULL) {
                dbgprintf(NULL, "Could not alloc!\n");
                goto fail;
        }

        /* Parse Start to vCard tokens (separated by ;) */
        token = 0;
        begin = line;
        for (i = 0; i < len; i++) {
                if (line[i] == ';') {
                        tokens[token++] = begin;
                        begin = line + i + 1;
                        line[i] = 0;
                }
        }
        /* Store last token */
        tokens[token] = begin;

        /* Compare first token, it must be in place */
        pos = Buffer;
        len = strlen(tokens[0]);
        if (strncasecmp(pos, tokens[0], len) != 0) {
                goto fail;
        }
        /* Advance position */
        pos += len;
        /* No need to check this token anymore */
        tokens[0][0] = 0;
        /* Initialize location */
        if (location != NULL) {
                *location = PBK_Location_Unknown;
        }

        /* Check remaining tokens */
        while (*pos != ':') {
                if (*pos == ';') {
                        pos++;
                } else {
                        dbgprintf(NULL, "Could not parse! (stopped at string: %s)\n", pos);
                        goto fail;
                }
                found = FALSE;
                for (token = 0; token < numtokens; token++) {
                        len = strlen(tokens[token]);
                        /* Skip already matched tokens */
                        if (len == 0) {
                                continue;
                        }
                        if (strncasecmp(pos, tokens[token], len) == 0) {
                                dbgprintf(NULL, "Found %s\n", tokens[token]);
                                /* Advance position */
                                pos += len;
                                /* We need to check one token less */
                                tokens[token][0] = 0;
                                found = TRUE;
                                break;
                        }
                }
                if (!found) {
                        if (strncasecmp(pos, "ENCODING=QUOTED-PRINTABLE", 25) == 0) {
                                quoted_printable = TRUE;
                                /* Advance position */
                                pos += 25;
                                found = TRUE;
                        } else if (strncasecmp(pos, "CHARSET=", 8) == 0) {
                                /* Advance position */
                                pos += 8;
                                /* Grab charset */
                                end = strchr(pos, ':');
                                end2 = strchr(pos, ';');
                                if (end == NULL && end2 == NULL) {
                                        dbgprintf(NULL, "Could not read charset!\n");
                                        goto fail;
                                } else if (end == NULL) {
                                        end = end2;
                                } else if (end2 != NULL && end2 < end) {
                                        end = end2;
                                }
                                /* We basically want strndup, but it is not portable */
                                charset = strdup(pos);
                                if (charset == NULL) {
                                        dbgprintf(NULL, "Could not alloc!\n");
                                        goto fail;
                                }
                                charset[end - pos] = 0;

                                pos = end;
                                found = TRUE;
                        } else if (strncasecmp(pos, "TZID=", 5) == 0) {
                                /* @todo: We ignore time zone for now */
                                /* Advance position */
                                pos += 5;
                                /* Go behind value */
                                end = strchr(pos, ':');
                                end2 = strchr(pos, ';');
                                if (end == NULL && end2 == NULL) {
                                        dbgprintf(NULL, "Could not read timezone!\n");
                                        goto fail;
                                } else if (end == NULL) {
                                        end = end2;
                                } else if (end2 != NULL && end2 < end) {
                                        end = end2;
                                }
                                pos = end;
                                found = TRUE;
                        } else if (strncasecmp(pos, "TYPE=", 5) == 0) {
                                /* We ignore TYPE= prefix */
                                pos += 5;

                                /* Now process types, which should be comma separated */
                                while (*pos != ':' && *pos != ';') {
                                        found = FALSE;

                                        /* Go through tokens to match */
                                        for (token = 0; token < numtokens; token++) {
                                                len = strlen(tokens[token]);
                                                /* Skip already matched tokens */
                                                if (len == 0) {
                                                        continue;
                                                }
                                                if (strncasecmp(pos, tokens[token], len) == 0) {
                                                        dbgprintf(NULL, "Found %s\n", tokens[token]);
                                                        /* Advance position */
                                                        pos += len;
                                                        /* We need to check one token less */
                                                        tokens[token][0] = 0;
                                                        found = TRUE;
                                                        break;
                                                }
                                        }

                                        if (!found) {
                                                if (strncasecmp(pos, "PREF", 4) == 0) {
                                                        /* We ignore pref token */
                                                        pos += 4;
                                                        found = TRUE;
                                                } else if (strncasecmp(pos, "WORK", 4) == 0) {
                                                        /* We ignore work token */
                                                        pos += 4;
                                                        found = TRUE;
                                                        if (location != NULL) {
                                                                *location = PBK_Location_Work;
                                                        }
                                                } else if (strncasecmp(pos, "HOME", 4) == 0) {
                                                        /* We ignore home token */
                                                        pos += 4;
                                                        found = TRUE;
                                                        if (location != NULL) {
                                                                *location = PBK_Location_Home;
                                                        }
                                                } else {
                                                        dbgprintf(NULL, "%s not found! (%s)\n", Start, pos);
                                                        goto fail;
                                                }
                                        }

                                        if (*pos == ';' || *pos == ':') {
                                                dbgprintf(NULL, "End of TYPE= string\n");
                                                break;
                                        } else if (*pos == ',') {
                                                /* Advance past separator */
                                                pos++;
                                        } else {
                                                dbgprintf(NULL, "Could not parse TYPE=! (stopped at string: %s)\n", pos);
                                                goto fail;
                                        }

                                }
                        } else if (strncasecmp(pos, "PREF", 4) == 0) {
                                /* We ignore pref token */
                                pos += 4;
                                found = TRUE;
                        } else if (location && strncasecmp(pos, "WORK", 4) == 0) {
                                /* We ignore pref token */
                                pos += 4;
                                found = TRUE;
                                *location = PBK_Location_Work;
                        } else if (location && strncasecmp(pos, "HOME", 4) == 0) {
                                /* We ignore pref token */
                                pos += 4;
                                found = TRUE;
                                *location = PBK_Location_Home;
                        }
                        if (!found) {
                                dbgprintf(NULL, "%s not found!\n", Start);
                                goto fail;
                        }
                }
        }
        /* Skip : */
        pos++;
        /* Length of rest */
        len = strlen(pos);

        /* Did we match all our tokens? */
        for (token = 0; token < numtokens; token++) {
                if (strlen(tokens[token]) > 0) {
                        dbgprintf(NULL, "All tokens did not match!\n");
                        goto fail;
                }
        }

        /* Decode the text */
        if (charset == NULL) {
                if (quoted_printable) {
                        if (UTF8) {
                                DecodeUTF8QuotedPrintable(Value, pos, len);
                        } else {
                                DecodeISO88591QuotedPrintable(Value, pos, len);
                        }
                } else {
                        if (UTF8) {
                                DecodeUTF8(Value, pos, len);
                        } else {
                                DecodeISO88591(Value, pos, len);
                        }
                }
        } else {
                if (strcasecmp(charset, "UTF-8") == 0||
                                strcasecmp(charset, "\"UTF-8\"") == 0
                                ) {
                        if (quoted_printable) {
                                DecodeUTF8QuotedPrintable(Value, pos, len);
                        } else {
                                DecodeUTF8(Value, pos, len);
                        }
                } else if (strcasecmp(charset, "UTF-7") == 0||
                                strcasecmp(charset, "\"UTF-7\"") == 0
                                ) {
                        if (quoted_printable) {
                                dbgprintf(NULL, "Unsupported charset: %s\n", charset);
                                goto fail;
                        } else {
                                DecodeUTF7(Value, pos, len);
                        }
                } else {
                        dbgprintf(NULL, "Unsupported charset: %s\n", charset);
                        goto fail;
                }
        }

        /* Postprocess escaped chars */
        len = UnicodeLength(Value);
        for (i = 0; i < len; i++) {
                if (Value[(2 * i)] == 0 && Value[(2 * i) + 1] == '\\') {
                        j = i + 1;
                        if (Value[(2 * j)] == 0 && (
                                                Value[(2 * j) + 1] == 'n' ||
                                                Value[(2 * j) + 1] == 'N')
                                                ) {
                                Value[(2 * i) + 1] = '\n';
                        } else if (Value[(2 * j)] == 0 && (
                                                Value[(2 * j) + 1] == 'r' ||
                                                Value[(2 * j) + 1] == 'R')
                                                ) {
                                Value[(2 * i) + 1] = '\r';
                        } else if (Value[(2 * j)] == 0 && Value[(2 * j) + 1] == '\\') {
                                Value[(2 * i) + 1] = '\\';
                        } else if (Value[(2 * j)] == 0 && Value[(2 * j) + 1] == ';') {
                                Value[(2 * i) + 1] = ';';
                        } else if (Value[(2 * j)] == 0 && Value[(2 * j) + 1] == ',') {
                                Value[(2 * i) + 1] = ',';
                        } else {
                                /* We ignore unknown for now */
                                continue;
                        }
                        /* Shift the string */
                        memmove(Value + (2 * j), Value + (2 * j) + 2, 2 * (len + 1 - j));
                        len--;
                }
        }

        ret = TRUE;
        dbgprintf(NULL, "ReadVCalText(%s) is \"%s\"\n", Start, DecodeUnicodeConsole(Value));
fail:
        free(line);
        line=NULL;
        free(tokens);
        tokens=NULL;
        free(charset);
        charset=NULL;
        return ret;
}

VC_Store()

GSM_Error VC_Store	(	char *	Buffer,
		const size_t	buff_len,
		size_t *	Pos,
		const char *	format,
			...
	)

Prints a string to a buffer with error checking.

Definition at line 208 of file gsmmisc.c.

References ERR_MOREMEMORY, and ERR_NONE.

Referenced by GSM_EncodeVCAL_RRULE(), GSM_EncodeVCARD(), VC_StoreDate(), and VC_StoreDateTime().

{
        va_list                 argp;
        int                     result;

        va_start(argp, format);
        result = vsnprintf(Buffer + (*Pos), buff_len - *Pos - 1, format, argp);
        va_end(argp);

        *Pos += result;
        if (*Pos >= buff_len - 1) return ERR_MOREMEMORY;

        return ERR_NONE;
}

VC_StoreBase64()

GSM_Error VC_StoreBase64	(	char *	Buffer,
		const size_t	buff_len,
		size_t *	Pos,
		const unsigned char *	data,
		const size_t	length
	)

Store base64 encoded string to buffer.

Definition at line 392 of file gsmmisc.c.

References EncodeBASE64(), ERR_MOREMEMORY, ERR_NONE, MIN, and VC_StoreLine().

Referenced by GSM_EncodeVCARD().

{
        char *buffer=NULL, *pos=NULL, linebuffer[80]={0};
        size_t len=0, current=0;
        char spacer[2]={0};
        GSM_Error error;

        /*
         * Need to be big enough to store base64 (what is *4/3, but *2 is safer
         * and we don't have to care about rounding and padding).
         */
        buffer = (char *)malloc(length * 2);
        if (buffer == NULL) return ERR_MOREMEMORY;

        spacer[0] = 0;
        spacer[1] = 0;


        EncodeBASE64(data, buffer, length);

        len = strlen(buffer);
        pos = buffer;

        /* Write at most 76 chars per line */
        while (len > 0) {
                current = MIN(len, 76);
                strncpy(linebuffer, pos, current);
                linebuffer[current] = 0;
                error =  VC_StoreLine(Buffer, buff_len, Pos, "%s%s", spacer, linebuffer);
                if (error != ERR_NONE) {
                        free(buffer);
                        buffer=NULL;
                        return error;
                }
                spacer[0] = ' ';
                len -= current;
                pos += current;
        }

        free(buffer);
        buffer=NULL;
        return ERR_NONE;
}

VC_StoreDate()

GSM_Error VC_StoreDate	(	char *	Buffer,
		const size_t	buff_len,
		size_t *	Pos,
		const GSM_DateTime *	Date,
		const char *	Start
	)

Definition at line 240 of file gsmmisc.c.

References GSM_DateTime::Day, ERR_NONE, GSM_DateTime::Month, VC_Store(), VC_StoreLine(), and GSM_DateTime::Year.

Referenced by GSM_EncodeVCAL_RRULE(), GSM_EncodeVCALENDAR(), and GSM_EncodeVCARD().

{
        GSM_Error error;

        if (Start != NULL) {
                error = VC_Store(Buffer, buff_len, Pos, "%s:", Start);
                if (error != ERR_NONE) return error;
        }
        error = VC_StoreLine(Buffer, buff_len, Pos,
                "%04d%02d%02d",
                        Date->Year, Date->Month, Date->Day);
        return error;
}

VC_StoreDateTime()

GSM_Error VC_StoreDateTime	(	char *	Buffer,
		const size_t	buff_len,
		size_t *	Pos,
		const GSM_DateTime *	Date,
		const char *	Start
	)

Definition at line 224 of file gsmmisc.c.

References GSM_DateTime::Day, ERR_NONE, GSM_DateTime::Hour, GSM_DateTime::Minute, GSM_DateTime::Month, GSM_DateTime::Second, GSM_DateTime::Timezone, VC_Store(), VC_StoreLine(), and GSM_DateTime::Year.

Referenced by GSM_EncodeVCALENDAR(), GSM_EncodeVCARD(), and GSM_EncodeVTODO().

{
        GSM_Error error;

        if (Start != NULL) {
                error = VC_Store(Buffer, buff_len, Pos, "%s:", Start);
                if (error != ERR_NONE) return error;
        }
        error = VC_StoreLine(Buffer, buff_len, Pos,
                "%04d%02d%02dT%02d%02d%02d%s",
                        Date->Year, Date->Month, Date->Day,
                        Date->Hour, Date->Minute, Date->Second,
                        Date->Timezone == 0 ? "Z" : "");
        return error;
}

VC_StoreLine()

GSM_Error VC_StoreLine	(	char *	Buffer,
		const size_t	buff_len,
		size_t *	Pos,
		const char *	format,
			...
	)

Prints a line (terminated with CRLF) to a buffer with error checking.

Definition at line 187 of file gsmmisc.c.

References ERR_MOREMEMORY, ERR_NONE, and PRINTF_STYLE.

Referenced by GSM_EncodeVCAL_RRULE(), GSM_EncodeVCALENDAR(), GSM_EncodeVCARD(), GSM_EncodeVNTFile(), GSM_EncodeVTODO(), VC_StoreBase64(), VC_StoreDate(), VC_StoreDateTime(), and VC_StoreText().

{
        va_list                 argp;
        int                     result;

        va_start(argp, format);
        result = vsnprintf(Buffer + (*Pos), buff_len - *Pos - 1, format, argp);
        va_end(argp);

        *Pos += result;
        if (*Pos >= buff_len - 1) return ERR_MOREMEMORY;

        result = snprintf(Buffer + (*Pos), buff_len - *Pos - 1, "%c%c", 13, 10);

        *Pos += result;
        if (*Pos >= buff_len - 1) return ERR_MOREMEMORY;

        return ERR_NONE;
}

VC_StoreText()

GSM_Error VC_StoreText	(	char *	Buffer,
		const size_t	buff_len,
		size_t *	Length,
		const unsigned char *	Text,
		const char *	Start,
		const gboolean	UTF8
	)

Stores text in vCalendar/vCard formatted buffer.

Parameters

[out]	Buffer	Buffer where output will be stored.
[in]	buff_len	Size of Buffer.
[in,out]	Length	Current position in output buffer (will be updated).
[in]	Text	Value to be stored.
[in]	Start	Name of field which is being stored.
[in]	UTF8	Whether text should be stored in UTF-8 without prefix.

Definition at line 360 of file gsmmisc.c.

References EncodeUTF8QuotedPrintable(), ERR_MOREMEMORY, ERR_NONE, UnicodeLength(), and VC_StoreLine().

Referenced by GSM_EncodeVCALENDAR(), GSM_EncodeVCARD(), GSM_EncodeVNTFile(), and GSM_EncodeVTODO().

{
        char *buffer=NULL;
        size_t len=0;
        GSM_Error error;

        len = UnicodeLength(Text);

        if (len == 0) return ERR_NONE;

        /* Need to be big enough to store quoted printable */
        buffer = (char *)malloc(len * 8);
        if (buffer == NULL) return ERR_MOREMEMORY;

        if (UTF8) {
                EncodeUTF8QuotedPrintable(buffer, Text);
                error =  VC_StoreLine(Buffer, buff_len, Pos, "%s:%s", Start, buffer);
        } else {
                EncodeUTF8QuotedPrintable(buffer, Text);
                if (UnicodeLength(Text) == strlen(buffer)) {
                        /* Text is plain ASCII */
                        error =  VC_StoreLine(Buffer, buff_len, Pos, "%s:%s", Start, buffer);
                } else {
                        error =  VC_StoreLine(Buffer, buff_len, Pos, "%s;CHARSET=UTF-8;ENCODING=QUOTED-PRINTABLE:%s", Start, buffer);
                }
        }

        free(buffer);
        buffer=NULL;
        return error;
}

VCALGetTextPart()

unsigned char* VCALGetTextPart	(	unsigned char *	Buff,
		int *	pos
	)

Definition at line 436 of file gsmmisc.c.

References CopyUnicodeString().

Referenced by GSM_DecodeVCARD().

{
        static unsigned char    tmp[1000];
        unsigned char           *start;

        start = Buff + *pos;
        while (Buff[*pos] != 0 || Buff[*pos + 1] != 0) {
                if (Buff[*pos] == 0 && Buff[*pos + 1] == ';') {
                        Buff[*pos + 1] = 0;
                        CopyUnicodeString(tmp, start);
                        Buff[*pos + 1] = ';';
                        *pos += 2;
                        return tmp;
                }
                *pos += 2;
        }
        if (start == Buff || (start[0] == 0 && start[1] == 0)) return NULL;
        CopyUnicodeString(tmp, start);
        return tmp;
}

Variable Documentation

Keys

struct keys_table_position Keys[]

static

Initial value:

= {
        {'m',GSM_KEY_MENU},             {'M',GSM_KEY_MENU},
        {'n',GSM_KEY_NAMES},            {'N',GSM_KEY_NAMES},
        {'p',GSM_KEY_POWER},            {'P',GSM_KEY_POWER},
        {'u',GSM_KEY_UP},               {'U',GSM_KEY_UP},
        {'d',GSM_KEY_DOWN},             {'D',GSM_KEY_DOWN},
        {'+',GSM_KEY_INCREASEVOLUME},   {'-',GSM_KEY_DECREASEVOLUME},
        {'1',GSM_KEY_1},                {'2',GSM_KEY_2},        {'3',GSM_KEY_3},
        {'4',GSM_KEY_4},                {'5',GSM_KEY_5},        {'6',GSM_KEY_6},
        {'7',GSM_KEY_7},                {'8',GSM_KEY_8},        {'9',GSM_KEY_9},
        {'*',GSM_KEY_ASTERISK},         {'0',GSM_KEY_0},        {'#',GSM_KEY_HASH},
        {'g',GSM_KEY_GREEN},            {'G',GSM_KEY_GREEN},
        {'r',GSM_KEY_RED},              {'R',GSM_KEY_RED},
        {'<',GSM_KEY_LEFT},             {'>',GSM_KEY_RIGHT},
        {'[',GSM_KEY_SOFT1},            {']',GSM_KEY_SOFT2},
        {'h',GSM_KEY_HEADSET},          {'H',GSM_KEY_HEADSET},
        {'c',GSM_KEY_CLEAR},            {'C',GSM_KEY_CLEAR},
        {'j',GSM_KEY_JOYSTICK},         {'J',GSM_KEY_JOYSTICK},
        {'f',GSM_KEY_CAMERA},           {'F',GSM_KEY_CAMERA},
        {'o',GSM_KEY_OPERATOR},         {'O',GSM_KEY_OPERATOR},
        {'m',GSM_KEY_MEDIA},            {'M',GSM_KEY_MEDIA},
        {'d',GSM_KEY_DESKTOP},          {'D',GSM_KEY_DESKTOP},
        {'@',GSM_KEY_RETURN},
        {' ',0}
}

Definition at line 23 of file gsmmisc.c.