Beispiel #1
0
/**
 * Add person and address data to cache.
 * \param cache     Cache.
 * \param folder    Folder where to add person, or NULL for root folder.
 * \param name      Common name.
 * \param address   EMail address.
 * \param remarks   Remarks.
 * \return Person added. Do not *NOT* to use the 
 *         <code>addrbook_free_xxx()</code> functions...; this will destroy
 *         the address book data.
 */
ItemPerson *addrcache_add_contact(
		AddressCache *cache, ItemFolder *folder, const gchar *name,
		const gchar *address, const gchar *remarks )
{
	ItemPerson *person = NULL;
	ItemEMail *email = NULL;
	ItemFolder *f = folder;

	cm_return_val_if_fail( cache != NULL, NULL );

	if( ! f ) f = cache->rootFolder;

	/* Create person object */
	person = addritem_create_item_person();
	addritem_person_set_common_name( person, name );
	addrcache_id_person( cache, person );
	addrcache_folder_add_person( cache, f, person );

	/* Create email object */
	email = addritem_create_item_email();
	addritem_email_set_address( email, address );
	addritem_email_set_remarks( email, remarks );
	addrcache_id_email( cache, email );
	addritem_person_add_email( person, email );
	cache->dirtyFlag = TRUE;

	return person;
}
Beispiel #2
0
/**
 * Process a single label entry field, parsing multiple e-mail address entries.
 *
 * \param pilotFile  JPilot control data.
 * \param labelEntry Label entry data.
 * \param person     Person.
 */
static void jpilot_parse_label( JPilotFile *pilotFile, gchar *labelEntry, ItemPerson *person ) {
	gchar buffer[ EMAIL_BUFSIZE ];
	ItemEMail *email;
	GList *list, *node;

	if( labelEntry ) {
		*buffer = '\0';
		strcpy( buffer, labelEntry );
		node = list = jpilot_parse_email( buffer );
		while( node ) {
			gchar convertBuff[JPILOT_LEN_LABEL];
			email = addritem_create_item_email();
			addritem_email_set_address( email, node->data );
			if (convert_charcode) {
				conv_sjistoeuc(convertBuff, JPILOT_LEN_LABEL, buffer);
				addritem_email_set_remarks(email, convertBuff);
			}
			else {
				addritem_email_set_remarks(email, buffer);
			}

			addrcache_id_email( pilotFile->addressCache, email );
			addrcache_person_add_email( pilotFile->addressCache, person, email );
			node = g_list_next( node );
		}
		mgu_free_dlist( list );
		list = NULL;
	}
}
Beispiel #3
0
/**
 * Create a shallow copy of specified email address item.
 * \param  item E-Mail to copy.
 * \return Copy of email, or <i>NULL</i> if null argument supplied.
 */
ItemEMail *addritem_copy_item_email( ItemEMail *item ) {
	ItemEMail *itemNew = NULL;
	if( item ) {
		itemNew = addritem_create_item_email();
		ADDRITEM_NAME(itemNew) = g_strdup( ADDRITEM_NAME(item) );
		itemNew->address = g_strdup( item->address );
		itemNew->remarks = g_strdup( item->remarks );
	}
	return itemNew;
}
Beispiel #4
0
/*
* Build an address list entry and append to list of address items.
*/
static void vcard_build_items(
	VCardFile *cardFile, GSList *listName, GSList *listAddr,
	GSList *listRem, GSList *listID )
{
	GSList *nodeName = listName;
	GSList *nodeID = listID;
	gchar *str;
	while( nodeName ) {
		GSList *nodeAddress = listAddr;
		GSList *nodeRemarks = listRem;
		ItemPerson *person = addritem_create_item_person();
		addritem_person_set_common_name( person, nodeName->data );
		while( nodeAddress ) {
			str = nodeAddress->data;
			if( *str != '\0' ) {
				ItemEMail *email = addritem_create_item_email();
				addritem_email_set_address( email, str );
				str = nodeRemarks->data;
				if( nodeRemarks ) {
					if( str ) {
						if( g_strcasecmp( str, "internet" ) != 0 ) {
							if( *str != '\0' )
								addritem_email_set_remarks( email, str );
						}
					}
				}
				addrcache_id_email( cardFile->addressCache, email );
				addrcache_person_add_email( cardFile->addressCache, person, email );
			}
			nodeAddress = g_slist_next( nodeAddress );
			nodeRemarks = g_slist_next( nodeRemarks );
		}
		if( person->listEMail ) {
			addrcache_id_person( cardFile->addressCache, person );
			addrcache_add_person( cardFile->addressCache, person );
			if( nodeID ) {
				str = nodeID->data;
				addritem_person_set_external_id( person, str );
			}
		}
		else {
			addritem_free_item_person( person );
		}
		nodeName = g_slist_next( nodeName );
		nodeID = g_slist_next( nodeID );
	}
}
Beispiel #5
0
/*
 * Insert person and address into address cache.
 * Enter: muttFile MUTT control data.
 *        cache    Address cache.
 *        address  E-Mail address.
 *        name     Name.
 * Return: E-Mail object, either inserted or found in hash table.
 */
static ItemEMail *mutt_insert_table(
		MuttFile *muttFile, AddressCache *cache, gchar *address,
		gchar *name )
{
	ItemPerson *person;
	ItemEMail *email;
	gchar *key;

	/* Test whether address already in hash table */
	key = g_strdup( address );
	g_strdown( key );
	email = g_hash_table_lookup( muttFile->uniqTable, key );

	if( email == NULL ) {
		/* No - create person */
		person = addritem_create_item_person();
		addritem_person_set_common_name( person, name );
		addrcache_id_person( cache, person );
		addrcache_add_person( cache, person );

		/* Add email for person */
		email = addritem_create_item_email();
		addritem_email_set_address( email, address );
		addrcache_id_email( cache, email );
		addrcache_person_add_email( cache, person, email );

		/* Insert entry */
		g_hash_table_insert( muttFile->uniqTable, key, email );
	}
	else {
		/* Yes - update person with longest name */
		person = ( ItemPerson * ) ADDRITEM_PARENT(email);
		if( strlen( name ) > strlen( ADDRITEM_NAME(person) ) ) {
			addritem_person_set_common_name( person, name );
		}

		/* Free up */
		g_free( key );
	}

	return email;
}
static GList* restore_or_add_email_address(AddressBookFile *abf,
																					 ItemPerson *item, GList *savedList,
																					 const gchar *email)
{
	ItemEMail *itemMail = NULL;
	GList *walk;
	gboolean found;
	gchar *addr;

	if(!email)
		return savedList;

	found = FALSE;
	for (walk = savedList; walk; walk = walk->next) {
		itemMail = walk->data;
		if(itemMail && itemMail->address) {
			addr = g_strchomp(g_strdup(itemMail->address));
			if (!strcmp(addr, email))
				found = TRUE;
			g_free(addr);
			if (found)
				break;
		}
	}

	if (found) {
		addritem_person_add_email(item, itemMail);
		savedList = g_list_delete_link(savedList, walk);
	}
	/* something's fishy here */
	else {
		ItemEMail *newEMail;
		newEMail = addritem_create_item_email();
		addritem_email_set_address(newEMail, email);
		addrcache_id_email(abf->addressCache, newEMail);
		addritem_person_add_email(item, newEMail);
		addrbook_set_dirty(abf,TRUE);
	}

	return savedList;
}
Beispiel #7
0
/*
* Build an address list entry and append to list of address items. Name is formatted
* as it appears in the common name (cn) attribute.
*/
static void syldap_build_items_cn( SyldapServer *ldapServer, GSList *listName, GSList *listAddr ) {
	ItemPerson *person;
	ItemEMail *email;
	GSList *nodeName = listName;

	while( nodeName ) {
		GSList *nodeAddress = listAddr;
		person = addritem_create_item_person();
		addritem_person_set_common_name( person, nodeName->data );
		addrcache_id_person( ldapServer->addressCache, person );
		addrcache_add_person( ldapServer->addressCache, person );

		while( nodeAddress ) {
			email = addritem_create_item_email();
			addritem_email_set_address( email, nodeAddress->data );
			addrcache_id_email( ldapServer->addressCache, email );
			addrcache_person_add_email( ldapServer->addressCache, person, email );
			nodeAddress = g_slist_next( nodeAddress );
			ldapServer->entriesRead++;
		}
		nodeName = g_slist_next( nodeName );
	}
}
Beispiel #8
0
/*
 * Unpack address, building new data inside cache.
 */
static void jpilot_load_address( JPilotFile *pilotFile, buf_rec *buf, ItemFolder *folderInd[] ) {
	struct Address addr;
	gchar **addrEnt;
	gint num, k;
	gint cat_id = 0;
	guint unique_id;
	guchar attrib;
	gchar fullName[ FULLNAME_BUFSIZE ];
	gchar bufEMail[ EMAIL_BUFSIZE ];
	ItemPerson *person;
	ItemEMail *email;
	gint *indPhoneLbl;
	gchar *labelEntry;
	GList *node;
	gchar* extID;
	struct AddressAppInfo *ai;
	gchar **firstName = NULL;
	gchar **lastName = NULL;
#if (PILOT_LINK_MAJOR > 11)
	pi_buffer_t *RecordBuffer;
#endif /* PILOT_LINK_0_12 */

	/* Retrieve address */
#if (PILOT_LINK_MAJOR < 12)
	num = unpack_Address( & addr, buf->buf, buf->size );
	if( num > 0 ) {
#else /* PILOT_LINK_0_12 */
	RecordBuffer = pi_buffer_new(buf->size);
	memcpy(RecordBuffer->data, buf->buf, buf->size);
	RecordBuffer->used = buf->size;
	num = unpack_Address( & addr, RecordBuffer, address_v1 );
	pi_buffer_free(RecordBuffer);
	if (num != -1) {
#endif
		gchar *nameConv;

		addrEnt = addr.entry;
		attrib = buf->attrib;
		unique_id = buf->unique_id;
		cat_id = attrib & 0x0F;

		*fullName = *bufEMail = '\0';

		if( addrEnt[ IND_LABEL_FIRSTNAME ] ) {
			firstName = g_strsplit( addrEnt[ IND_LABEL_FIRSTNAME ], "\01", 2 );
		}
		if( addrEnt[ IND_LABEL_LASTNAME ] ) {
			lastName = g_strsplit( addrEnt[ IND_LABEL_LASTNAME ], "\01", 2 );
		}

		if( name_order == FAMILY_LAST ) {
			g_snprintf( fullName, FULLNAME_BUFSIZE, "%s %s",
				    firstName ? firstName[0] : "",
				    lastName ? lastName[0] : "" );
		}
		else {
			g_snprintf( fullName, FULLNAME_BUFSIZE, "%s %s",
				    lastName ? lastName[0] : "",
				    firstName ? firstName[0] : "" );
		}

		if( firstName ) {
			g_strfreev( firstName );
		}
		if( lastName ) {
			g_strfreev( lastName );
		}

		g_strstrip( fullName );

		nameConv = jpilot_convert_encoding( fullName );
		strncpy2( fullName, nameConv, FULLNAME_BUFSIZE );
		g_free( nameConv );

		person = addritem_create_item_person();
		addritem_person_set_common_name( person, fullName );
		addritem_person_set_first_name( person, addrEnt[ IND_LABEL_FIRSTNAME ] );
		addritem_person_set_last_name( person, addrEnt[ IND_LABEL_LASTNAME ] );
		addrcache_id_person( pilotFile->addressCache, person );

		extID = g_strdup_printf( "%d", unique_id );
		addritem_person_set_external_id( person, extID );
		g_free( extID );
		extID = NULL;

		/* Pointer to address metadata. */
		ai = & pilotFile->addrInfo;

		/* Add entry for each email address listed under phone labels. */
		indPhoneLbl = addr.phoneLabel;
		for( k = 0; k < JPILOT_NUM_ADDR_PHONE; k++ ) {
			gint ind;

			ind = indPhoneLbl[k];
			/*
			* fprintf( stdout, "%d : %d : %20s : %s\n", k, ind,
			* ai->phoneLabels[ind], addrEnt[3+k] );
			*/
			if( indPhoneLbl[k] == IND_PHONE_EMAIL ) {
				labelEntry = addrEnt[ OFFSET_PHONE_LABEL + k ];
				if( labelEntry ) {
					strcpy( bufEMail, labelEntry );
					g_strchug( bufEMail );
					g_strchomp( bufEMail );

					email = addritem_create_item_email();
					addritem_email_set_address( email, bufEMail );
					addrcache_id_email( pilotFile->addressCache, email );
					addrcache_person_add_email
						( pilotFile->addressCache, person, email );
				}
			}
		}

		/* Add entry for each custom label */
		node = pilotFile->labelInd;
		while( node ) {
			gint ind;

			ind = GPOINTER_TO_INT( node->data );
			if( ind > -1 ) {
				/*
				* fprintf( stdout, "%d : %20s : %s\n", ind, ai->labels[ind],
				* addrEnt[ind] );
				*/
				labelEntry = addrEnt[ind];
				if( labelEntry ) {
					gchar *convertBuff;

					strcpy( bufEMail, labelEntry );
					g_strchug( bufEMail );
					g_strchomp( bufEMail );

					email = addritem_create_item_email();
					addritem_email_set_address( email, bufEMail );

					convertBuff = jpilot_convert_encoding( ai->labels[ind] );
					addritem_email_set_remarks( email, convertBuff );
					g_free( convertBuff );

					addrcache_id_email( pilotFile->addressCache, email );
					addrcache_person_add_email
						( pilotFile->addressCache, person, email );
				}
			}

			node = g_list_next( node );
		}

		if( person->listEMail ) {
			if( cat_id > -1 && cat_id < JPILOT_NUM_CATEG ) {
				/* Add to specified category */
				addrcache_folder_add_person
					( pilotFile->addressCache, folderInd[cat_id], person );
			}
			else {
				/* Add to root folder */
				addrcache_add_person( pilotFile->addressCache, person );
			}
		}
		else {
			addritem_free_item_person( person );
			person = NULL;
		}
	}
}

/*
 * Free up address list.
 */
static void jpilot_free_addrlist( GList *records ) {
	GList *node;
	buf_rec *br;

	node = records;
	while( node ) {
		br = node->data;
		free( br );
		node->data = NULL;
		node = g_list_next( node );
	}

	/* Free up list */
	g_list_free( records );
}
Beispiel #9
0
/**
 * Build an address list entry and append to list of address items. Name is formatted
 * as "<first-name> <last-name>".
 *
 * \param  cache     Address cache to load.
 * \param  qry Query object to process.
 * \param  dn        DN for entry found on server.
 * \param  listName  List of common names for entry; see notes below.
 * \param  listAddr  List of EMail addresses for entry.
 * \param  listFirst List of first names for entry.
 * \param  listLast  List of last names for entry.
 *
 * \return List of ItemEMail objects.
 *
 * Notes:
 * 1) Each LDAP server entry may have multiple LDAP attributes with the same
 *    name. For example, a single entry for a person may have more than one
 *    common name, email address, etc.
*
 * 2) The DN for the entry is unique for the server.
 */
static GList *ldapqry_build_items_fl(
		AddressCache *cache, LdapQuery *qry, gchar *dn,
		GSList *listName, GSList *listAddr, GSList *listFirst,
		GSList *listLast, GSList *listDisplay, GSList *attributes )
{
	GSList *nodeAddress, *cur;
	gchar *firstName = NULL, *lastName = NULL, *fullName = NULL;
	gboolean allocated = FALSE;
	ItemPerson *person;
	ItemEMail *email;
	ItemFolder *folder;
	gchar *picfile = NULL;
	GList *listReturn = NULL;

	folder = ADDRQUERY_FOLDER(qry);
	if( folder == NULL ) return listReturn;
	if( listAddr == NULL ) return listReturn;

	if ( listDisplay ) {
		allocated = FALSE;
		fullName = listDisplay->data;
	}

	/* Find longest first name in list */
	firstName = mgu_slist_longest_entry( listFirst );

	/* Format last name */
	if( listLast ) {
		lastName = listLast->data;
	}

	if ( fullName == NULL ) {
		/* Find longest common name */
		allocated = FALSE;
		fullName = mgu_slist_longest_entry( listName );
		if( fullName == NULL ) {
			/* Format a full name from first and last names */
			if( firstName ) {
				if( lastName ) {
					fullName = g_strdup_printf( "%s %s", firstName, lastName );
				}
				else {
					fullName = g_strdup_printf( "%s", firstName );
				}
			}
			else {
				if( lastName ) {
					fullName = g_strdup_printf( "%s", lastName );
				}
			}
			if( fullName ) {
				g_strstrip( fullName );
				allocated = TRUE;
			}
		}
	}

	/* Add person into folder */		
	person = addritem_create_item_person();
	addritem_person_set_common_name( person, fullName );
	addritem_person_set_first_name( person, firstName );
	addritem_person_set_last_name( person, lastName );
	addritem_person_set_nick_name( person, fullName );
	addrcache_id_person( cache, person );
	addritem_person_set_external_id( person, dn );
	
	for (cur = attributes; cur; cur = cur->next) {
		UserAttribute *attrib = addritem_copy_attribute((UserAttribute *)cur->data);
		if (attrib->name && strcmp(attrib->name, "jpegPhoto")) {
			addritem_person_add_attribute( person, attrib );
		} else {
			if (qry->server && qry->server->control) {
				gchar *dir = g_strconcat( get_rc_dir(), G_DIR_SEPARATOR_S, 
							ADDRBOOK_DIR, G_DIR_SEPARATOR_S, NULL );
				gchar *filename = g_strdup_printf("%s-%s-%s",
					qry->server->control->hostName?qry->server->control->hostName:"nohost", 
					qry->server->control->baseDN?qry->server->control->baseDN:"nobase", 
					dn);
				picfile = g_strdup_printf("%s%s.png", dir, filename);
				addritem_person_set_picture( person, filename );
				rename_force(attrib->value, picfile);
				g_free(filename);
				g_free(picfile);
				g_free(dir);
			}
		}
	}
	
	addrcache_folder_add_person( cache, ADDRQUERY_FOLDER(qry), person );

	qry->entriesRead++;

	/* Add each address item */
	nodeAddress = listAddr;
	while( nodeAddress ) {
		email = addritem_create_item_email();
		addritem_email_set_address( email, nodeAddress->data );
		addrcache_id_email( cache, email );
		addrcache_person_add_email( cache, person, email );
		addritem_person_add_email( person, email );
		/*if (debug_get_mode()) {
			addritem_print_item_email(email, stdout);
		}*/
		listReturn = g_list_append( listReturn, email );
		nodeAddress = g_slist_next( nodeAddress );
	}

	/* Free any allocated memory */
	if( allocated ) {
		g_free( fullName );
	}
	fullName = firstName = lastName = NULL;

	return listReturn;
}
Beispiel #10
0
/*
* Build an address list entry and append to list of address items. Name is formatted
* as "<first-name> <last-name>".
*/
static void syldap_build_items_fl( SyldapServer *ldapServer, GSList *listAddr, GSList *listFirst, GSList *listLast  ) {
	GSList *nodeFirst = listFirst;
	GSList *nodeAddress = listAddr;
	gchar *firstName = NULL, *lastName = NULL, *fullName = NULL;
	gint iLen = 0, iLenT = 0;
	ItemPerson *person;
	ItemEMail *email;

	/* Find longest first name in list */
	while( nodeFirst ) {
		if( firstName == NULL ) {
			firstName = nodeFirst->data;
			iLen = strlen( firstName );
		}
		else {
			if( ( iLenT = strlen( nodeFirst->data ) ) > iLen ) {
				firstName = nodeFirst->data;
				iLen = iLenT;
			}
		}
		nodeFirst = g_slist_next( nodeFirst );
	}

	/* Format name */
	if( listLast ) {
		lastName = listLast->data;
	}

	if( firstName ) {
		if( lastName ) {
			fullName = g_strdup_printf( "%s %s", firstName, lastName );
		}
		else {
			fullName = g_strdup_printf( "%s", firstName );
		}
	}
	else {
		if( lastName ) {
			fullName = g_strdup_printf( "%s", lastName );
		}
	}
	if( fullName ) {
		g_strchug( fullName ); g_strchomp( fullName );
	}

	if( nodeAddress ) {
		person = addritem_create_item_person();
		addritem_person_set_common_name( person, fullName );
		addritem_person_set_first_name( person, firstName );
		addritem_person_set_last_name( person, lastName );
		addrcache_id_person( ldapServer->addressCache, person );
		addrcache_add_person( ldapServer->addressCache, person );
	}

	/* Add address item */
	while( nodeAddress ) {
		email = addritem_create_item_email();
		addritem_email_set_address( email, nodeAddress->data );
		addrcache_id_email( ldapServer->addressCache, email );
		addrcache_person_add_email( ldapServer->addressCache, person, email );
		nodeAddress = g_slist_next( nodeAddress );
		ldapServer->entriesRead++;
	}
	g_free( fullName );
	fullName = firstName = lastName = NULL;

}
Beispiel #11
0
/**
 * Build an address list entry and append to list of address items in the
 * address cache. Name is formatted as "<first-name> <last-name>".
 * \param ldifFile LDIF import control object.
 * \param rec      LDIF field object.
 * \param cache    Address cache to be populated with data.
 */
static void ldif_build_items(
		LdifFile *ldifFile, Ldif_ParsedRec *rec, AddressCache *cache )
{
	GSList *nodeFirst;
	GSList *nodeAddress;
	GSList *nodeAttr;
	gchar *firstName = NULL, *lastName = NULL, *fullName = NULL;
	gchar *nickName = NULL;
	gint iLen = 0, iLenT = 0;
	ItemPerson *person;
	ItemEMail *email;

	nodeAddress = rec->listAddress;
//	if( nodeAddress == NULL ) return;

	/* Find longest first name in list */
	nodeFirst = rec->listFName;
	while( nodeFirst ) {
		if( firstName == NULL ) {
			firstName = nodeFirst->data;
			iLen = strlen( firstName );
		}
		else {
			if( ( iLenT = strlen( nodeFirst->data ) ) > iLen ) {
				firstName = nodeFirst->data;
				iLen = iLenT;
			}
		}
		nodeFirst = g_slist_next( nodeFirst );
	}

	/* Format name */
	if( rec->listLName ) {
		lastName = rec->listLName->data;
	}

	if( firstName ) {
		if( lastName ) {
			fullName = g_strdup_printf(
				"%s %s", firstName, lastName );
		}
		else {
			fullName = g_strdup_printf( "%s", firstName );
		}
	}
	else {
		if( lastName ) {
			fullName = g_strdup_printf( "%s", lastName );
		}
	}
	
	if (!fullName || strlen(fullName) == 0) {
		g_free(fullName);
		fullName = NULL;
		if (rec->listCName)
			fullName = g_strdup(rec->listCName->data);
	}
	
	if( fullName ) {
		g_strstrip( fullName );
	}

	if( rec->listNName ) {
		nickName = rec->listNName->data;
	}

	person = addritem_create_item_person();
	addritem_person_set_common_name( person, fullName );
	addritem_person_set_first_name( person, firstName );
	addritem_person_set_last_name( person, lastName );
	addritem_person_set_nick_name( person, nickName );
	addrcache_id_person( cache, person );
	addrcache_add_person( cache, person );
	++ldifFile->importCount;

	/* Add address item */
	while( nodeAddress ) {
		email = addritem_create_item_email();
		addritem_email_set_address( email, nodeAddress->data );
		addrcache_id_email( cache, email );
		addrcache_person_add_email( cache, person, email );
		nodeAddress = g_slist_next( nodeAddress );
	}
	g_free( fullName );
	fullName = firstName = lastName = NULL;

	/* Add user attributes */
	nodeAttr = rec->userAttr;
	while( nodeAttr ) {
		Ldif_UserAttr *attr = nodeAttr->data;
		UserAttribute *attrib = addritem_create_attribute();
		addritem_attrib_set_name( attrib, attr->name );
		addritem_attrib_set_value( attrib, attr->value );
		addritem_person_add_attribute( person, attrib );
		nodeAttr = g_slist_next( nodeAttr );
	}
	nodeAttr = NULL;
}