/***********************************************************************
*
* Function: u_read_buf
*
* Summary: read buffer
*
* Parameters: pi_socket_t*, char* to buffer, length of buffer
*
* Returns: number of bytes read
*
***********************************************************************/
static int
u_read_buf (pi_socket_t *ps, pi_buffer_t *buf, size_t len, int flags)
{
struct pi_usb_data *data = (struct pi_usb_data *)ps->device->data;
size_t rbuf = data->buf_size;
if (rbuf > len)
rbuf = len;
if (pi_buffer_append (buf, data->buf, rbuf) == NULL) {
errno = ENOMEM;
return pi_set_error(ps->sd, PI_ERR_GENERIC_MEMORY);
}
if (flags != PI_MSG_PEEK) {
data->buf_size -= rbuf;
if (data->buf_size > 0)
memmove(data->buf, &data->buf[rbuf], data->buf_size);
}
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG,
"DEV RX linuxusb read %d bytes from read-ahead buffer\n", rbuf));
return rbuf;
}
static char *print_remote (GnomePilotRecord *remote)
{
static char buff[ 4096 ];
struct Address addr;
#ifdef PILOT_LINK_0_12
pi_buffer_t * buffer;
#endif
if (remote == NULL) {
sprintf (buff, "[NULL]");
return buff;
}
memset (&addr, 0, sizeof (struct Address));
#ifdef PILOT_LINK_0_12
buffer = pi_buffer_new(DLP_BUF_SIZE);
if(buffer == NULL){
sprintf (buff, "[NULL]");
return buff;
}
if(pi_buffer_append(buffer, remote->record, remote->length)==NULL){
sprintf (buff, "[NULL]");
return buff;
}
unpack_Address (&addr, buffer, address_v1);
pi_buffer_free(buffer);
#else
unpack_Address (&addr, remote->record, remote->length);
#endif
g_snprintf (buff, 4096, "['%s' '%s' '%s']",
addr.entry[entryLastname] ?
addr.entry[entryLastname] : "",
addr.entry[entryFirstname] ?
addr.entry[entryFirstname] : "",
addr.entry[entryCompany] ?
addr.entry[entryCompany] : "");
free_Address (&addr);
return buff;
}
static char *print_remote (GnomePilotRecord *remote)
{
static char buff[ 64 ];
struct Memo memo;
#ifdef PILOT_LINK_0_12
pi_buffer_t *buffer;
#endif
if (remote == NULL) {
sprintf (buff, "[NULL]");
return buff;
}
memset (&memo, 0, sizeof (struct Memo));
#ifdef PILOT_LINK_0_12
buffer = pi_buffer_new(DLP_BUF_SIZE);
if(buffer == NULL){
sprintf (buff, "[NULL]");
return buff;
}
if(pi_buffer_append(buffer, remote->record, remote->length)==NULL){
sprintf (buff, "[NULL]");
return buff;
}
unpack_Memo (&memo, buffer, memo_v1);
pi_buffer_free(buffer);
#else
unpack_Memo (&memo, remote->record, remote->length);
#endif
g_snprintf (buff, 64, "['%s']",
memo.text ?
memo.text : "");
free_Memo (&memo);
return buff;
}
static EContact *
ecard_from_remote_record(EAddrConduitContext *ctxt,
GnomePilotRecord *remote,
EContact *in_contact)
{
struct Address address;
EContact *contact;
EContactName *name;
EContactAddress *eaddress;
EContactField mailing_address;
char *txt, *find, *full_name;
EContactField next_mail, next_home, next_work, next_fax;
EContactField next_other, next_main, next_pager, next_mobile;
int i;
#ifdef PILOT_LINK_0_12
pi_buffer_t * buffer;
#endif
g_return_val_if_fail(remote!=NULL,NULL);
memset (&address, 0, sizeof (struct Address));
#ifdef PILOT_LINK_0_12
buffer = pi_buffer_new(DLP_BUF_SIZE);
if(buffer == NULL){
pi_set_error(ctxt->dbi->pilot_socket, PI_ERR_GENERIC_MEMORY);
return NULL;
}
if(pi_buffer_append(buffer, remote->record, remote->length)==NULL){
pi_set_error(ctxt->dbi->pilot_socket, PI_ERR_GENERIC_MEMORY);
return NULL;
}
unpack_Address (&address, buffer, address_v1);
pi_buffer_free(buffer);
#else
unpack_Address (&address, remote->record, remote->length);
#endif
if (in_contact == NULL)
contact = e_contact_new ();
else
contact = e_contact_duplicate (in_contact);
/* Name */
name = e_contact_name_new ();
name->given = get_entry_text (address, entryFirstname);
name->family = get_entry_text (address, entryLastname);
full_name = e_contact_name_to_string (name);
e_contact_set (contact, E_CONTACT_FULL_NAME, full_name);
e_contact_name_free (name);
/* File As */
if (!full_name || !*full_name)
set_contact_text (contact, E_CONTACT_FILE_AS, address, entryCompany);
g_free (full_name);
/* Title and Company */
set_contact_text (contact, E_CONTACT_TITLE, address, entryTitle);
set_contact_text (contact, E_CONTACT_ORG, address, entryCompany);
/* Address */
mailing_address = -1;
if ((eaddress = e_contact_get (contact, ctxt->cfg->default_address))) {
mailing_address = ctxt->cfg->default_address;
e_contact_address_free (eaddress);
} else {
for (i = E_CONTACT_FIRST_ADDRESS_ID; i <= E_CONTACT_LAST_ADDRESS_ID; i++) {
if ((eaddress = e_contact_get (contact, i))) {
e_contact_address_free (eaddress);
mailing_address = i;
break;
}
}
}
if (mailing_address == -1)
mailing_address = ctxt->cfg->default_address;
eaddress = g_new0 (EContactAddress, 1);
txt = get_entry_text (address, entryAddress);
if (txt && (find = strchr (txt, '\n')) != NULL) {
*find = '\0';
find++;
} else {
find = NULL;
}
eaddress->street = txt;
eaddress->ext = find != NULL ? g_strdup (find) : g_strdup ("");
eaddress->locality = get_entry_text (address, entryCity);
eaddress->region = get_entry_text (address, entryState);
eaddress->country = get_entry_text (address, entryCountry);
eaddress->code = get_entry_text (address, entryZip);
e_contact_set (contact, mailing_address, eaddress);
e_contact_address_free (eaddress);
/* Phone numbers */
get_next_init (&next_mail, &next_home, &next_work, &next_fax,
&next_other, &next_main, &next_pager, &next_mobile);
for (i = entryPhone1; i <= entryPhone5; i++) {
int phonelabel = address.phoneLabel[i - entryPhone1];
char *phonenum = get_entry_text (address, i);
if (phonelabel == LABEL_EMAIL && !is_next_done (next_mail)) {
e_contact_set (contact, next_mail, phonenum);
next_mail = get_next_mail (&next_mail);
} else if (phonelabel == LABEL_HOME && !is_next_done (next_home)) {
e_contact_set (contact, next_home, phonenum);
next_home = get_next_home (&next_home);
} else if (phonelabel == LABEL_WORK && !is_next_done (next_work)) {
e_contact_set (contact, next_work, phonenum);
next_work = get_next_work (&next_work);
} else if (phonelabel == LABEL_FAX && !is_next_done (next_fax)) {
e_contact_set (contact, next_fax, phonenum);
next_fax = get_next_fax (&next_fax);
} else if (phonelabel == LABEL_OTHER && !is_next_done (next_other)) {
e_contact_set (contact, next_other, phonenum);
next_other = get_next_other (&next_other);
} else if (phonelabel == LABEL_MAIN && !is_next_done (next_main)) {
e_contact_set (contact, next_main, phonenum);
next_main = get_next_main (&next_main);
} else if (phonelabel == LABEL_PAGER && !is_next_done (next_pager)) {
e_contact_set (contact, next_pager, phonenum);
next_pager = get_next_pager (&next_pager);
} else if (phonelabel == LABEL_MOBILE && !is_next_done (next_mobile)) {
e_contact_set (contact, next_mobile, phonenum);
next_mobile = get_next_mobile (&next_mobile);
}
g_free (phonenum);
}
/* Note */
set_contact_text (contact, E_CONTACT_NOTE, address, entryNote);
free_Address(&address);
return contact;
}
static ECalComponent *
comp_from_remote_record (GnomePilotConduitSyncAbs *conduit,
GnomePilotRecord *remote,
ECalComponent *in_comp,
icaltimezone *timezone,
struct MemoAppInfo *ai)
{
ECalComponent *comp;
struct Memo memo;
struct icaltimetype now;
icaltimezone *utc_zone;
char *txt, *txt2, *txt3;
int i;
#ifdef PILOT_LINK_0_12
pi_buffer_t * buffer;
#endif
g_return_val_if_fail (remote != NULL, NULL);
#ifdef PILOT_LINK_0_12
buffer = pi_buffer_new(DLP_BUF_SIZE);
if(buffer == NULL){
return NULL;
}
if(pi_buffer_append(buffer, remote->record, remote->length)==NULL){
return NULL;
}
unpack_Memo (&memo, buffer, memo_v1);
pi_buffer_free(buffer);
#else
memset (&memo, 0, sizeof (struct Memo));
unpack_Memo (&memo, remote->record, remote->length);
#endif
utc_zone = icaltimezone_get_utc_timezone ();
now = icaltime_from_timet_with_zone (time (NULL), FALSE,
utc_zone);
if (in_comp == NULL) {
comp = e_cal_component_new ();
e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_JOURNAL);
e_cal_component_set_created (comp, &now);
} else {
comp = e_cal_component_clone (in_comp);
}
e_cal_component_set_last_modified (comp, &now);
/*Category support*/
e_pilot_remote_category_to_local(remote->category, comp, &(ai->category));
/* The iCal description field */
if (!memo.text) {
e_cal_component_set_comment_list (comp, NULL);
e_cal_component_set_summary(comp, NULL);
} else {
int idxToUse = -1, ntext = strlen(memo.text);
gboolean foundNL = FALSE;
GSList l;
ECalComponentText text, sumText;
for(i = 0; i<ntext && i<50; i++){
if(memo.text[i] == '\n'){
idxToUse = i;
foundNL = TRUE;
break;
}
}
if(foundNL == FALSE){
if(ntext > 50){
txt2 = g_strndup(memo.text, 50);
}
else{
txt2 = g_strdup(memo.text);
}
}
else{
txt2 = g_strndup(memo.text, idxToUse); /* cuts off '\n' */
}
sumText.value = txt3 = e_pilot_utf8_from_pchar(txt2);
sumText.altrep = NULL;
text.value = txt = e_pilot_utf8_from_pchar (memo.text);
text.altrep = NULL;
l.data = &text;
l.next = NULL;
e_cal_component_set_summary(comp, &sumText);
e_cal_component_set_description_list (comp, &l);
free (txt);
g_free(txt2);
free(txt3);
}
e_cal_component_set_transparency (comp, E_CAL_COMPONENT_TRANSP_NONE);
if (remote->secret)
e_cal_component_set_classification (comp, E_CAL_COMPONENT_CLASS_PRIVATE);
else
e_cal_component_set_classification (comp, E_CAL_COMPONENT_CLASS_PUBLIC);
e_cal_component_commit_sequence (comp);
free_Memo(&memo);
return comp;
}
static int
u_read_i(struct pi_socket *ps, pi_buffer_t *buf, size_t len, int flags, int timeout)
{
if (!RD_running)
return PI_ERR_SOCK_DISCONNECTED;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "%s %d (%s): %d %d %d\n",
__FILE__, __LINE__, __FUNCTION__, len, flags, timeout));
pthread_mutex_lock (&RD_buffer_mutex);
if (flags & PI_MSG_PEEK && len > 256)
len = 256;
if (RD_buffer_used < len) {
struct timeval now;
struct timespec when, nownow;
int last_used;
gettimeofday(&now, NULL);
when.tv_sec = now.tv_sec + timeout / 1000;
when.tv_nsec = (now.tv_usec + (timeout % 1000) * 1000) * 1000;
if (when.tv_nsec >= 1000000000) {
when.tv_nsec -= 1000000000;
when.tv_sec++;
}
RD_wanted = len;
do {
last_used = RD_buffer_used;
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "%s %d (%s): %d %d.\n",
__FILE__, __LINE__, __FUNCTION__, len, RD_buffer_used));
if (timeout) {
gettimeofday(&now, NULL);
nownow.tv_sec = now.tv_sec;
nownow.tv_nsec = now.tv_usec * 1000;
if ((nownow.tv_sec == when.tv_sec ? (nownow.tv_nsec > when.tv_nsec) : (nownow.tv_sec > when.tv_sec))) {
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "%s %d (%s): %d %d.\n",
__FILE__, __LINE__, __FUNCTION__, len, RD_buffer_used));
break;
}
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "%s %d (%s): %d %d.\n",
__FILE__, __LINE__, __FUNCTION__, len, RD_buffer_used));
if (pthread_cond_timedwait (&RD_buffer_available_cond, &RD_buffer_mutex, &when) == ETIMEDOUT) {
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "%s %d (%s): %d %d.\n",
__FILE__, __LINE__, __FUNCTION__, len, RD_buffer_used));
break;
}
} else
pthread_cond_wait (&RD_buffer_available_cond, &RD_buffer_mutex);
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "%s %d (%s): %d %d.\n",
__FILE__, __LINE__, __FUNCTION__, len, RD_buffer_used));
} while (RD_buffer_used < len);
RD_wanted = 0;
}
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "%s %d (%s): %d %d.\n",
__FILE__, __LINE__, __FUNCTION__, len, RD_buffer_used));
if (!RD_running) {
pthread_mutex_unlock (&RD_buffer_mutex);
return PI_ERR_SOCK_DISCONNECTED;
}
if (RD_buffer_used < len)
len = RD_buffer_used;
if (len && buf) {
pi_buffer_append (buf, RD_buffer, len);
if (!(flags & PI_MSG_PEEK)) {
RD_buffer_used -= len;
if (RD_buffer_used)
memmove (RD_buffer, RD_buffer + len, RD_buffer_used);
if ((RD_buffer_size - RD_buffer_used) > (1024 * 1024)) {
/* If we have more then 1M free in the buffer, shrink it. */
RD_buffer_size = ((RD_buffer_used + 0xfffe) & ~0xffff) - 1;
RD_buffer = realloc (RD_buffer, RD_buffer_size);
}
}
}
pthread_mutex_unlock (&RD_buffer_mutex);
LOG((PI_DBG_DEV, PI_DBG_LVL_DEBUG, "%s %d (%s).\n",
__FILE__, __LINE__, __FUNCTION__));
return len;
}