| /* |
| * OBEX Server |
| * |
| * Copyright (C) 2008-2010 Intel Corporation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #include <string.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdint.h> |
| #include <ctype.h> |
| #include <errno.h> |
| |
| #include <glib.h> |
| #include <gdbus/gdbus.h> |
| |
| #include "vcard.h" |
| |
| #define ADDR_FIELD_AMOUNT 7 |
| #define LEN_MAX 128 |
| #define TYPE_INTERNATIONAL 145 |
| |
| #define PHONEBOOK_FLAG_CACHED 0x1 |
| |
| #define FILTER_VERSION (1 << 0) |
| #define FILTER_FN (1 << 1) |
| #define FILTER_N (1 << 2) |
| #define FILTER_PHOTO (1 << 3) |
| #define FILTER_BDAY (1 << 4) |
| #define FILTER_ADR (1 << 5) |
| #define FILTER_LABEL (1 << 6) |
| #define FILTER_TEL (1 << 7) |
| #define FILTER_EMAIL (1 << 8) |
| #define FILTER_MAILER (1 << 9) |
| #define FILTER_TZ (1 << 10) |
| #define FILTER_GEO (1 << 11) |
| #define FILTER_TITLE (1 << 12) |
| #define FILTER_ROLE (1 << 13) |
| #define FILTER_LOGO (1 << 14) |
| #define FILTER_AGENT (1 << 15) |
| #define FILTER_ORG (1 << 16) |
| #define FILTER_NOTE (1 << 17) |
| #define FILTER_REV (1 << 18) |
| #define FILTER_SOUND (1 << 19) |
| #define FILTER_URL (1 << 20) |
| #define FILTER_UID (1 << 21) |
| #define FILTER_KEY (1 << 22) |
| #define FILTER_NICKNAME (1 << 23) |
| #define FILTER_CATEGORIES (1 << 24) |
| #define FILTER_PROID (1 << 25) |
| #define FILTER_CLASS (1 << 26) |
| #define FILTER_SORT_STRING (1 << 27) |
| #define FILTER_X_IRMC_CALL_DATETIME (1 << 28) |
| |
| #define FORMAT_VCARD21 0x00 |
| #define FORMAT_VCARD30 0x01 |
| |
| #define QP_LINE_LEN 75 |
| #define QP_CHAR_LEN 3 |
| #define QP_CR 0x0D |
| #define QP_LF 0x0A |
| #define QP_ESC 0x5C |
| #define QP_SOFT_LINE_BREAK "=" |
| #define QP_SELECT "\n!\"#$=@[\\]^`{|}~" |
| #define ASCII_LIMIT 0x7F |
| |
| /* according to RFC 2425, the output string may need folding */ |
| static void vcard_printf(GString *str, const char *fmt, ...) |
| { |
| char buf[1024]; |
| va_list ap; |
| int len_temp, line_number, i; |
| unsigned int line_delimit = 75; |
| |
| va_start(ap, fmt); |
| vsnprintf(buf, sizeof(buf), fmt, ap); |
| va_end(ap); |
| |
| line_number = strlen(buf) / line_delimit + 1; |
| |
| for (i = 0; i < line_number; i++) { |
| len_temp = MIN(line_delimit, strlen(buf) - line_delimit * i); |
| g_string_append_len(str, buf + line_delimit * i, len_temp); |
| if (i != line_number - 1) |
| g_string_append(str, "\r\n "); |
| } |
| |
| g_string_append(str, "\r\n"); |
| } |
| |
| /* According to RFC 2426, we need escape following characters: |
| * '\n', '\r', ';', ',', '\'. |
| */ |
| static void add_slash(char *dest, const char *src, int len_max, int len) |
| { |
| int i, j; |
| |
| for (i = 0, j = 0; i < len && j + 1 < len_max; i++, j++) { |
| /* filling dest buffer - last field need to be reserved |
| * for '\0'*/ |
| switch (src[i]) { |
| case '\n': |
| if (j + 2 >= len_max) |
| /* not enough space in the buffer to put char |
| * preceded with escaping sequence (and '\0' in |
| * the end) */ |
| goto done; |
| |
| dest[j++] = '\\'; |
| dest[j] = 'n'; |
| break; |
| case '\r': |
| if (j + 2 >= len_max) |
| goto done; |
| |
| dest[j++] = '\\'; |
| dest[j] = 'r'; |
| break; |
| case '\\': |
| case ';': |
| case ',': |
| if (j + 2 >= len_max) |
| goto done; |
| |
| dest[j++] = '\\'; |
| default: |
| dest[j] = src[i]; |
| break; |
| } |
| } |
| |
| done: |
| dest[j] = 0; |
| } |
| |
| static void escape_semicolon(char *dest, const char *src, int len_max, int len) |
| { |
| int i, j; |
| |
| for (i = 0, j = 0; i < len && j + 1 < len_max; i++, j++) { |
| if (src[i] == ';') { |
| if (j + 2 >= len_max) |
| break; |
| |
| dest[j++] = '\\'; |
| } |
| |
| dest[j] = src[i]; |
| } |
| |
| dest[j] = 0; |
| } |
| |
| static void set_escape(uint8_t format, char *dest, const char *src, |
| int len_max, int len) |
| { |
| if (format == FORMAT_VCARD30) |
| add_slash(dest, src, len_max, len); |
| else if (format == FORMAT_VCARD21) |
| escape_semicolon(dest, src, len_max, len); |
| } |
| |
| static void get_escaped_fields(uint8_t format, char **fields, ...) |
| { |
| va_list ap; |
| GString *line; |
| char *field; |
| char escaped[LEN_MAX]; |
| |
| va_start(ap, fields); |
| line = g_string_new(""); |
| |
| for (field = va_arg(ap, char *); field; ) { |
| set_escape(format, escaped, field, LEN_MAX, strlen(field)); |
| g_string_append(line, escaped); |
| |
| field = va_arg(ap, char *); |
| |
| if (field) |
| g_string_append(line, ";"); |
| } |
| |
| va_end(ap); |
| |
| *fields = g_string_free(line, FALSE); |
| } |
| |
| static gboolean set_qp_encoding(char c) |
| { |
| unsigned char q = c; |
| |
| if (strchr(QP_SELECT, q) != NULL) |
| return TRUE; |
| |
| if (q < '!' || q > '~') |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| static void append_qp_break_line(GString *vcards, size_t *limit) |
| { |
| /* Quoted Printable lines of text must be limited to less than 76 |
| * characters and terminated by Quoted Printable softline break |
| * sequence of "=" (if some more characters left) */ |
| g_string_append(vcards, QP_SOFT_LINE_BREAK); |
| g_string_append(vcards, "\r\n "); |
| *limit = QP_LINE_LEN - 1; |
| } |
| |
| static void append_qp_ascii(GString *vcards, size_t *limit, char c) |
| { |
| if (*limit == 0) |
| append_qp_break_line(vcards, limit); |
| |
| g_string_append_c(vcards, c); |
| --*limit; |
| } |
| |
| static void append_qp_hex(GString *vcards, size_t *limit, char c) |
| { |
| if (*limit < QP_CHAR_LEN) |
| append_qp_break_line(vcards, limit); |
| |
| g_string_append_printf(vcards, "=%2.2X", (unsigned char) c); |
| *limit -= QP_CHAR_LEN; |
| } |
| |
| static void append_qp_new_line(GString *vcards, size_t *limit) |
| { |
| /* Multiple lines of text are separated with a Quoted Printable CRLF |
| * sequence of "=0D" followed by "=0A" followed by a Quoted Printable |
| * softline break sequence of "=" */ |
| append_qp_hex(vcards, limit, QP_CR); |
| append_qp_hex(vcards, limit, QP_LF); |
| append_qp_break_line(vcards, limit); |
| } |
| |
| static gboolean utf8_select(const char *field) |
| { |
| const char *pos; |
| |
| if (g_utf8_validate(field, -1, NULL) == FALSE) |
| return FALSE; |
| |
| for (pos = field; *pos != '\0'; pos = g_utf8_next_char(pos)) { |
| /* Test for non-standard UTF-8 character (out of range |
| * standard ASCII set), composed of more than single byte |
| * and represented by 32-bit value greater than 0x7F */ |
| if (g_utf8_get_char(pos) > ASCII_LIMIT) |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| static void vcard_qp_print_encoded(GString *vcards, const char *desc, ...) |
| { |
| const char *field, *charset = ""; |
| const char *encoding = ";ENCODING=QUOTED-PRINTABLE"; |
| size_t limit, param_len; |
| va_list ap; |
| |
| va_start(ap, desc); |
| |
| for (field = va_arg(ap, char *); field; field = va_arg(ap, char *)) { |
| if (utf8_select(field) == TRUE) { |
| charset = ";CHARSET=UTF-8"; |
| break; |
| } |
| } |
| |
| va_end(ap); |
| |
| vcard_printf(vcards, "%s%s%s:", desc, encoding, charset); |
| g_string_truncate(vcards, vcards->len - 2); |
| |
| param_len = strlen(desc) + strlen(encoding) + strlen(charset) + 1; |
| limit = QP_LINE_LEN - param_len; |
| |
| va_start(ap, desc); |
| |
| for (field = va_arg(ap, char *); field != NULL; ) { |
| size_t i, size = strlen(field); |
| |
| for (i = 0; i < size; ++i) { |
| if (set_qp_encoding(field[i])) { |
| if (field[i] == '\n') { |
| append_qp_new_line(vcards, &limit); |
| continue; |
| } |
| |
| append_qp_hex(vcards, &limit, field[i]); |
| } else { |
| /* According to vCard 2.1 spec. semicolons in |
| * property parameter value must be escaped */ |
| if (field[i] == ';') |
| append_qp_hex(vcards, &limit, QP_ESC); |
| |
| append_qp_ascii(vcards, &limit, field[i]); |
| } |
| } |
| |
| field = va_arg(ap, char *); |
| if (field) |
| append_qp_ascii(vcards, &limit, ';'); |
| } |
| |
| va_end(ap); |
| |
| g_string_append(vcards, "\r\n"); |
| } |
| |
| static gboolean select_qp_encoding(uint8_t format, ...) |
| { |
| char *field; |
| va_list ap; |
| |
| if (format != FORMAT_VCARD21) |
| return FALSE; |
| |
| va_start(ap, format); |
| |
| for (field = va_arg(ap, char *); field; field = va_arg(ap, char *)) { |
| int i; |
| unsigned char c; |
| |
| if (strpbrk(field, QP_SELECT)) { |
| va_end(ap); |
| return TRUE; |
| } |
| |
| /* Quoted Printable encoding is selected if there is |
| * a character, which value is out of range standard |
| * ASCII set, since it may be a part of some |
| * non-standard character such as specified by UTF-8 */ |
| for (i = 0; (c = field[i]) != '\0'; ++i) { |
| if (c > ASCII_LIMIT) { |
| va_end(ap); |
| return TRUE; |
| } |
| } |
| } |
| |
| va_end(ap); |
| |
| return FALSE; |
| } |
| |
| static void vcard_printf_begin(GString *vcards, uint8_t format) |
| { |
| vcard_printf(vcards, "BEGIN:VCARD"); |
| |
| if (format == FORMAT_VCARD30) |
| vcard_printf(vcards, "VERSION:3.0"); |
| else if (format == FORMAT_VCARD21) |
| vcard_printf(vcards, "VERSION:2.1"); |
| } |
| |
| /* check if there is at least one contact field with personal data present */ |
| static gboolean contact_fields_present(struct phonebook_contact * contact) |
| { |
| if (contact->family && strlen(contact->family) > 0) |
| return TRUE; |
| |
| if (contact->given && strlen(contact->given) > 0) |
| return TRUE; |
| |
| if (contact->additional && strlen(contact->additional) > 0) |
| return TRUE; |
| |
| if (contact->prefix && strlen(contact->prefix) > 0) |
| return TRUE; |
| |
| if (contact->suffix && strlen(contact->suffix) > 0) |
| return TRUE; |
| |
| /* none of the personal data fields are present*/ |
| return FALSE; |
| } |
| |
| static void vcard_printf_name(GString *vcards, uint8_t format, |
| struct phonebook_contact *contact) |
| { |
| char *fields; |
| |
| if (contact_fields_present(contact) == FALSE) { |
| /* If fields are empty, add only 'N:' as parameter. |
| * This is crucial for some devices (Nokia BH-903) which |
| * have problems with history listings and can't determine |
| * that a parameter is really empty if there are unnecessary |
| * characters after 'N:' (e.g. 'N:;;;;'). |
| * We need to add only'N:' param - without semicolons. |
| */ |
| vcard_printf(vcards, "N:"); |
| return; |
| } |
| |
| if (select_qp_encoding(format, contact->family, contact->given, |
| contact->additional, contact->prefix, |
| contact->suffix, NULL)) { |
| vcard_qp_print_encoded(vcards, "N", contact->family, |
| contact->given, contact->additional, |
| contact->prefix, contact->suffix, |
| NULL); |
| return; |
| } |
| |
| get_escaped_fields(format, &fields, contact->family, |
| contact->given, contact->additional, |
| contact->prefix, contact->suffix, |
| NULL); |
| |
| vcard_printf(vcards, "N:%s", fields); |
| |
| g_free(fields); |
| } |
| |
| static void vcard_printf_fullname(GString *vcards, uint8_t format, |
| const char *text) |
| { |
| char field[LEN_MAX]; |
| |
| if (!text || strlen(text) == 0) { |
| vcard_printf(vcards, "FN:"); |
| return; |
| } |
| |
| if (select_qp_encoding(format, text, NULL)) { |
| vcard_qp_print_encoded(vcards, "FN", text, NULL); |
| return; |
| } |
| |
| set_escape(format, field, text, LEN_MAX, strlen(text)); |
| vcard_printf(vcards, "FN:%s", field); |
| } |
| |
| static void vcard_printf_number(GString *vcards, uint8_t format, |
| const char *number, int type, |
| enum phonebook_number_type category) |
| { |
| const char *intl = "", *category_string = ""; |
| char buf[LEN_MAX], field[LEN_MAX]; |
| |
| /* TEL is a mandatory field, include even if empty */ |
| if (!number || !strlen(number) || !type) { |
| vcard_printf(vcards, "TEL:"); |
| return; |
| } |
| |
| switch (category) { |
| case TEL_TYPE_HOME: |
| if (format == FORMAT_VCARD21) |
| category_string = "HOME;VOICE"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=HOME;TYPE=VOICE"; |
| break; |
| case TEL_TYPE_MOBILE: |
| if (format == FORMAT_VCARD21) |
| category_string = "CELL;VOICE"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=CELL;TYPE=VOICE"; |
| break; |
| case TEL_TYPE_FAX: |
| if (format == FORMAT_VCARD21) |
| category_string = "FAX"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=FAX"; |
| break; |
| case TEL_TYPE_WORK: |
| if (format == FORMAT_VCARD21) |
| category_string = "WORK;VOICE"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=WORK;TYPE=VOICE"; |
| break; |
| case TEL_TYPE_OTHER: |
| if (format == FORMAT_VCARD21) |
| category_string = "OTHER;VOICE"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=OTHER;TYPE=VOICE"; |
| break; |
| } |
| |
| if ((type == TYPE_INTERNATIONAL) && (number[0] != '+')) |
| intl = "+"; |
| |
| snprintf(field, sizeof(field), "%s%s", intl, number); |
| |
| if (select_qp_encoding(format, number, NULL)) { |
| snprintf(buf, sizeof(buf), "TEL;%s", category_string); |
| vcard_qp_print_encoded(vcards, buf, field, NULL); |
| return; |
| } |
| |
| vcard_printf(vcards, "TEL;%s:%s", category_string, field); |
| } |
| |
| static void vcard_printf_tag(GString *vcards, uint8_t format, |
| const char *tag, const char *category, |
| const char *fld) |
| { |
| int len; |
| char *separator = "", *type = ""; |
| char buf[LEN_MAX], field[LEN_MAX]; |
| |
| if (tag == NULL || strlen(tag) == 0) |
| return; |
| |
| if (fld == NULL || (len = strlen(fld)) == 0) { |
| vcard_printf(vcards, "%s:", tag); |
| return; |
| } |
| |
| if (category && strlen(category)) { |
| separator = ";"; |
| if (format == FORMAT_VCARD30) |
| type = "TYPE="; |
| } else { |
| category = ""; |
| } |
| |
| snprintf(buf, LEN_MAX, "%s%s%s%s", tag, separator, type, category); |
| |
| if (select_qp_encoding(format, fld, NULL)) { |
| vcard_qp_print_encoded(vcards, buf, fld, NULL); |
| return; |
| } |
| |
| set_escape(format, field, fld, LEN_MAX, len); |
| vcard_printf(vcards, "%s:%s", buf, field); |
| } |
| |
| static void vcard_printf_email(GString *vcards, uint8_t format, |
| const char *address, |
| enum phonebook_field_type category) |
| { |
| const char *category_string = ""; |
| char buf[LEN_MAX], field[LEN_MAX]; |
| int len = 0; |
| |
| if (!address || !(len = strlen(address))) { |
| vcard_printf(vcards, "EMAIL:"); |
| return; |
| } |
| switch (category) { |
| case FIELD_TYPE_HOME: |
| if (format == FORMAT_VCARD21) |
| category_string = "INTERNET;HOME"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=INTERNET;TYPE=HOME"; |
| break; |
| case FIELD_TYPE_WORK: |
| if (format == FORMAT_VCARD21) |
| category_string = "INTERNET;WORK"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=INTERNET;TYPE=WORK"; |
| break; |
| default: |
| if (format == FORMAT_VCARD21) |
| category_string = "INTERNET"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=INTERNET;TYPE=OTHER"; |
| } |
| |
| if (select_qp_encoding(format, address, NULL)) { |
| snprintf(buf, sizeof(buf), "EMAIL;%s", category_string); |
| vcard_qp_print_encoded(vcards, buf, address, NULL); |
| return; |
| } |
| |
| set_escape(format, field, address, LEN_MAX, len); |
| vcard_printf(vcards, "EMAIL;%s:%s", category_string, field); |
| } |
| |
| static void vcard_printf_url(GString *vcards, uint8_t format, |
| const char *url, |
| enum phonebook_field_type category) |
| { |
| const char *category_string = ""; |
| char buf[LEN_MAX], field[LEN_MAX]; |
| |
| if (!url || strlen(url) == 0) { |
| vcard_printf(vcards, "URL:"); |
| return; |
| } |
| |
| switch (category) { |
| case FIELD_TYPE_HOME: |
| if (format == FORMAT_VCARD21) |
| category_string = "INTERNET;HOME"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=INTERNET;TYPE=HOME"; |
| break; |
| case FIELD_TYPE_WORK: |
| if (format == FORMAT_VCARD21) |
| category_string = "INTERNET;WORK"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=INTERNET;TYPE=WORK"; |
| break; |
| default: |
| if (format == FORMAT_VCARD21) |
| category_string = "INTERNET"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=INTERNET"; |
| break; |
| } |
| |
| if (select_qp_encoding(format, url, NULL)) { |
| snprintf(buf, sizeof(buf), "URL;%s", category_string); |
| vcard_qp_print_encoded(vcards, buf, url, NULL); |
| return; |
| } |
| |
| set_escape(format, field, url, LEN_MAX, strlen(url)); |
| vcard_printf(vcards, "URL;%s:%s", category_string, field); |
| } |
| |
| static gboolean org_fields_present(struct phonebook_contact *contact) |
| { |
| if (contact->company && strlen(contact->company)) |
| return TRUE; |
| |
| if (contact->department && strlen(contact->department)) |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| static void vcard_printf_org(GString *vcards, uint8_t format, |
| struct phonebook_contact *contact) |
| { |
| char *fields; |
| |
| if (org_fields_present(contact) == FALSE) |
| return; |
| |
| if (select_qp_encoding(format, contact->company, |
| contact->department, NULL)) { |
| vcard_qp_print_encoded(vcards, "ORG", contact->company, |
| contact->department, NULL); |
| return; |
| } |
| |
| get_escaped_fields(format, &fields, contact->company, |
| contact->department, NULL); |
| |
| vcard_printf(vcards, "ORG:%s", fields); |
| |
| g_free(fields); |
| } |
| |
| static void vcard_printf_address(GString *vcards, uint8_t format, |
| struct phonebook_addr *address) |
| { |
| char *fields, field_esc[LEN_MAX]; |
| const char *category_string = ""; |
| char buf[LEN_MAX], *address_fields[ADDR_FIELD_AMOUNT]; |
| int i; |
| size_t len; |
| GSList *l; |
| |
| if (!address) { |
| vcard_printf(vcards, "ADR:"); |
| return; |
| } |
| |
| switch (address->type) { |
| case FIELD_TYPE_HOME: |
| if (format == FORMAT_VCARD21) |
| category_string = "HOME"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=HOME"; |
| break; |
| case FIELD_TYPE_WORK: |
| if (format == FORMAT_VCARD21) |
| category_string = "WORK"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=WORK"; |
| break; |
| default: |
| if (format == FORMAT_VCARD21) |
| category_string = "OTHER"; |
| else if (format == FORMAT_VCARD30) |
| category_string = "TYPE=OTHER"; |
| break; |
| } |
| |
| for (i = 0, l = address->fields; l; l = l->next) |
| address_fields[i++] = l->data; |
| |
| if (select_qp_encoding(format, address_fields[0], address_fields[1], |
| address_fields[2], address_fields[3], |
| address_fields[4], address_fields[5], |
| address_fields[6], NULL)) { |
| snprintf(buf, sizeof(buf), "ADR;%s", category_string); |
| vcard_qp_print_encoded(vcards, buf, |
| address_fields[0], address_fields[1], |
| address_fields[2], address_fields[3], |
| address_fields[4], address_fields[5], |
| address_fields[6], NULL); |
| return; |
| } |
| |
| /* allocate enough memory to insert address fields separated by ';' |
| * and terminated by '\0' */ |
| len = ADDR_FIELD_AMOUNT * LEN_MAX; |
| fields = g_malloc0(len); |
| |
| for (l = address->fields; l; l = l->next) { |
| char *field = l->data; |
| |
| if (field) { |
| set_escape(format, field_esc, field, LEN_MAX, |
| strlen(field)); |
| g_strlcat(fields, field_esc, len); |
| } |
| |
| if (l->next) |
| /* not adding ';' after last addr field */ |
| g_strlcat(fields, ";", len); |
| } |
| |
| vcard_printf(vcards,"ADR;%s:%s", category_string, fields); |
| |
| g_free(fields); |
| } |
| |
| static void vcard_printf_datetime(GString *vcards, uint8_t format, |
| struct phonebook_contact *contact) |
| { |
| const char *type; |
| char buf[LEN_MAX]; |
| |
| switch (contact->calltype) { |
| case CALL_TYPE_MISSED: |
| type = "MISSED"; |
| break; |
| |
| case CALL_TYPE_INCOMING: |
| type = "RECEIVED"; |
| break; |
| |
| case CALL_TYPE_OUTGOING: |
| type = "DIALED"; |
| break; |
| |
| case CALL_TYPE_NOT_A_CALL: |
| default: |
| return; |
| } |
| |
| if (select_qp_encoding(format, contact->datetime, NULL)) { |
| snprintf(buf, sizeof(buf), "X-IRMC-CALL-DATETIME;%s", type); |
| vcard_qp_print_encoded(vcards, buf, contact->datetime, NULL); |
| return; |
| } |
| |
| vcard_printf(vcards, "X-IRMC-CALL-DATETIME;%s:%s", type, |
| contact->datetime); |
| } |
| |
| static void vcard_printf_end(GString *vcards) |
| { |
| vcard_printf(vcards, "END:VCARD"); |
| } |
| |
| void phonebook_add_contact(GString *vcards, struct phonebook_contact *contact, |
| uint64_t filter, uint8_t format) |
| { |
| if (format == FORMAT_VCARD30 && filter) |
| filter |= (FILTER_VERSION | FILTER_FN | FILTER_N | FILTER_TEL); |
| else if (format == FORMAT_VCARD21 && filter) |
| filter |= (FILTER_VERSION | FILTER_N | FILTER_TEL); |
| else |
| filter = (FILTER_VERSION | FILTER_UID | FILTER_N | FILTER_FN | |
| FILTER_TEL | FILTER_EMAIL | FILTER_ADR | |
| FILTER_BDAY | FILTER_NICKNAME | FILTER_URL | |
| FILTER_PHOTO | FILTER_ORG | FILTER_ROLE | |
| FILTER_TITLE | FILTER_X_IRMC_CALL_DATETIME); |
| |
| vcard_printf_begin(vcards, format); |
| |
| if (filter & FILTER_UID && *contact->uid) |
| vcard_printf_tag(vcards, format, "UID", NULL, contact->uid); |
| |
| if (filter & FILTER_N) |
| vcard_printf_name(vcards, format, contact); |
| |
| if (filter & FILTER_FN && (*contact->fullname || |
| format == FORMAT_VCARD30)) |
| vcard_printf_fullname(vcards, format, contact->fullname); |
| |
| if (filter & FILTER_TEL) { |
| GSList *l = contact->numbers; |
| |
| if (g_slist_length(l) == 0) |
| vcard_printf_number(vcards, format, NULL, 1, |
| TEL_TYPE_OTHER); |
| |
| for (; l; l = l->next) { |
| struct phonebook_field *number = l->data; |
| |
| vcard_printf_number(vcards, format, number->text, 1, |
| number->type); |
| } |
| } |
| |
| if (filter & FILTER_EMAIL) { |
| GSList *l = contact->emails; |
| |
| for (; l; l = l->next) { |
| struct phonebook_field *email = l->data; |
| vcard_printf_email(vcards, format, email->text, |
| email->type); |
| } |
| } |
| |
| if (filter & FILTER_ADR) { |
| GSList *l = contact->addresses; |
| |
| for (; l; l = l->next) { |
| struct phonebook_addr *addr = l->data; |
| vcard_printf_address(vcards, format, addr); |
| } |
| } |
| |
| if (filter & FILTER_BDAY && *contact->birthday) |
| vcard_printf_tag(vcards, format, "BDAY", NULL, |
| contact->birthday); |
| |
| if (filter & FILTER_NICKNAME && *contact->nickname) |
| vcard_printf_tag(vcards, format, "NICKNAME", NULL, |
| contact->nickname); |
| |
| if (filter & FILTER_URL) { |
| GSList *l = contact->urls; |
| |
| for (; l; l = l->next) { |
| struct phonebook_field *url = l->data; |
| vcard_printf_url(vcards, format, url->text, url->type); |
| } |
| } |
| |
| if (filter & FILTER_PHOTO && *contact->photo) |
| vcard_printf_tag(vcards, format, "PHOTO", NULL, |
| contact->photo); |
| |
| if (filter & FILTER_ORG) |
| vcard_printf_org(vcards, format, contact); |
| |
| if (filter & FILTER_ROLE && *contact->role) |
| vcard_printf_tag(vcards, format, "ROLE", NULL, contact->role); |
| |
| if (filter & FILTER_TITLE && *contact->title) |
| vcard_printf_tag(vcards, format, "TITLE", NULL, contact->title); |
| |
| if (filter & FILTER_X_IRMC_CALL_DATETIME) |
| vcard_printf_datetime(vcards, format, contact); |
| |
| vcard_printf_end(vcards); |
| } |
| |
| static void field_free(gpointer data) |
| { |
| struct phonebook_field *field = data; |
| |
| g_free(field->text); |
| g_free(field); |
| } |
| |
| void phonebook_addr_free(gpointer addr) |
| { |
| struct phonebook_addr *address = addr; |
| |
| g_slist_free_full(address->fields, g_free); |
| g_free(address); |
| } |
| |
| void phonebook_contact_free(struct phonebook_contact *contact) |
| { |
| if (contact == NULL) |
| return; |
| |
| g_slist_free_full(contact->numbers, field_free); |
| g_slist_free_full(contact->emails, field_free); |
| g_slist_free_full(contact->addresses, phonebook_addr_free); |
| g_slist_free_full(contact->urls, field_free); |
| |
| g_free(contact->uid); |
| g_free(contact->fullname); |
| g_free(contact->given); |
| g_free(contact->family); |
| g_free(contact->additional); |
| g_free(contact->prefix); |
| g_free(contact->suffix); |
| g_free(contact->birthday); |
| g_free(contact->nickname); |
| g_free(contact->photo); |
| g_free(contact->company); |
| g_free(contact->department); |
| g_free(contact->role); |
| g_free(contact->title); |
| g_free(contact->datetime); |
| g_free(contact); |
| } |