libpurple/protocols/novell/nmuserrecord.c

   1 /*
   2  * nmuserrecord.c
   3  *
   4  * Copyright (c) 2004 Novell, Inc. All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA        02111-1301      USA
  18  *
  19  */
  20
  21 #include <glib.h>
  22 #include <string.h>
  23 #include "nmuserrecord.h"
  24 #include "nmfield.h"
  25 #include "nmuser.h"
  26
  27 struct _NMUserRecord
  28 {
  29         NMSTATUS_T status;
  30         char *status_text;
  31         char *dn;
  32         char *cn;
  33         char *display_id;
  34         char *fname;
  35         char *lname;
  36         char *full_name;
  37         NMField *fields;
  38         gboolean auth_attr;
  39         gpointer data;
  40         int ref_count;
  41 };
  42
  43 struct _NMProperty
  44 {
  45         char *tag;
  46         char *value;
  47 };
  48
  49 static int count = 0;
  50
  51 /* API functions */
  52
  53 NMUserRecord *
  54 nm_create_user_record()
  55 {
  56         NMUserRecord *user_record = g_new0(NMUserRecord, 1);
  57
  58         user_record->ref_count = 1;
  59
  60         purple_debug(PURPLE_DEBUG_INFO, "novell", "Creating user_record, total=%d\n",
  61                            count++);
  62
  63         return user_record;
  64 }
  65
  66 static char *
  67 _get_attribute_value(NMField *field)
  68 {
  69         char *value = NULL;
  70
  71         if (field->ptr_value == NULL)
  72                 return NULL;
  73
  74         if (field->type == NMFIELD_TYPE_UTF8 || field->type == NMFIELD_TYPE_DN) {
  75
  76                 value = (char *)field->ptr_value;
  77
  78         } else if (field->type == NMFIELD_TYPE_MV) {
  79
  80                 /* Need to handle multi-valued returns, for now
  81                  * just pick the first value and return it
  82                  */
  83                 NMField *tmp = (NMField *)field->ptr_value;
  84                 if (tmp->type == NMFIELD_TYPE_UTF8 || tmp->type == NMFIELD_TYPE_DN) {
  85                         value = (char *)tmp->ptr_value;
  86                 } else {
  87                         return NULL;
  88                 }
  89
  90         } else {
  91                 return NULL;
  92         }
  93
  94         return g_strdup(value);
  95 }
  96 /*
  97  * This creates a user_record for the reference list the
  98  * field array that is passed in should be a
  99  * NM_A_FA_USER_DETAILS array.
 100  */
 101 NMUserRecord *
 102 nm_create_user_record_from_fields(NMField * details)
 103 {
 104         NMUserRecord *user_record;
 105         NMField *field, *fields = details;
 106
 107         if (details == NULL) {
 108                 return NULL;
 109         }
 110
 111         if (details->type == NMFIELD_TYPE_ARRAY) {
 112                 if (details->ptr_value == NULL)
 113                         return NULL;
 114                 fields = (NMField *) details->ptr_value;
 115         }
 116
 117         user_record = nm_create_user_record();
 118
 119         if ((field = nm_locate_field(NM_A_SZ_AUTH_ATTRIBUTE, fields))) {
 120
 121                 if (field->ptr_value) {
 122                         user_record->display_id = _get_attribute_value(field);
 123                         user_record->auth_attr = TRUE;
 124                 }
 125         }
 126
 127         if ((field = nm_locate_field(NM_A_SZ_DN, fields))) {
 128
 129                 if (field->ptr_value) {
 130                         user_record->dn = _get_attribute_value(field);
 131                 }
 132         }
 133
 134         if ((field = nm_locate_field("CN", fields))) {
 135
 136                 if (field->ptr_value) {
 137                         user_record->cn = _get_attribute_value(field);
 138                 }
 139         }
 140
 141         if ((field = nm_locate_field("Given Name", fields))) {
 142
 143                 if (field->ptr_value) {
 144                         user_record->fname = _get_attribute_value(field);
 145                 }
 146         }
 147
 148         if ((field = nm_locate_field("Surname", fields))) {
 149
 150                 if (field->ptr_value) {
 151                         user_record->lname = _get_attribute_value(field);
 152                 }
 153         }
 154
 155         if ((field = nm_locate_field("Full Name", fields))) {
 156
 157                 if (field->ptr_value) {
 158                         user_record->full_name = _get_attribute_value(field);
 159                 }
 160         }
 161
 162         if ((field = nm_locate_field(NM_A_SZ_STATUS, fields))) {
 163
 164                 if (field->ptr_value)
 165                         user_record->status = atoi((char *) field->ptr_value);
 166
 167         }
 168
 169         if ((field = nm_locate_field(NM_A_SZ_MESSAGE_BODY, fields))) {
 170
 171                 if (field->ptr_value)
 172                         user_record->status_text = g_strdup((char *) field->ptr_value);
 173
 174         }
 175
 176         user_record->fields = nm_copy_field_array(fields);
 177
 178         return user_record;
 179 }
 180
 181 void
 182 nm_user_record_copy(NMUserRecord * dest, NMUserRecord * src)
 183 {
 184         if (dest == NULL || src == NULL)
 185                 return;
 186
 187         dest->status = src->status;
 188
 189         /* Copy status text */
 190         g_free(dest->status_text);
 191         dest->status_text = NULL;
 192
 193         if (src->status_text)
 194                 dest->status_text = g_strdup(src->status_text);
 195
 196         /* Copy DN */
 197         g_free(dest->dn);
 198         dest->dn = NULL;
 199
 200         if (src->dn)
 201                 dest->dn = g_strdup(src->dn);
 202
 203         /* Copy CN */
 204         g_free(dest->cn);
 205         dest->cn = NULL;
 206
 207         if (src->cn)
 208                 dest->cn = g_strdup(src->cn);
 209
 210         /* Copy display id */
 211         g_free(dest->display_id);
 212         dest->display_id = NULL;
 213
 214         if (src->display_id)
 215                 dest->display_id = g_strdup(src->display_id);
 216
 217         /* Copy first name */
 218         g_free(dest->fname);
 219         dest->fname = NULL;
 220
 221         if (src->fname)
 222                 dest->fname = g_strdup(src->fname);
 223
 224         /* Copy last name */
 225         g_free(dest->lname);
 226         dest->lname = NULL;
 227
 228         if (src->lname)
 229                 dest->lname = g_strdup(src->lname);
 230
 231         /* Copy full name */
 232         g_free(dest->full_name);
 233         dest->full_name = NULL;
 234
 235         if (src->full_name)
 236                 dest->full_name = g_strdup(src->full_name);
 237
 238         /* Copy fields */
 239         if (src->fields) {
 240
 241                 if (dest->fields) {
 242                         nm_free_fields(&dest->fields);
 243                 }
 244
 245                 dest->fields = nm_copy_field_array(src->fields);
 246         }
 247
 248         /* Copy data */
 249         dest->data = src->data;
 250 }
 251
 252 void
 253 nm_user_record_add_ref(NMUserRecord * user_record)
 254 {
 255         if (user_record)
 256                 user_record->ref_count++;
 257 }
 258
 259 void
 260 nm_release_user_record(NMUserRecord * user_record)
 261 {
 262         if (--(user_record->ref_count) == 0) {
 263
 264                 purple_debug(PURPLE_DEBUG_INFO, "novell",
 265                                    "Releasing user_record, total=%d\n", --count);
 266
 267                 g_free(user_record->dn);
 268                 g_free(user_record->cn);
 269                 g_free(user_record->display_id);
 270                 g_free(user_record->fname);
 271                 g_free(user_record->lname);
 272                 g_free(user_record->full_name);
 273                 g_free(user_record->status_text);
 274
 275                 nm_free_fields(&user_record->fields);
 276
 277                 g_free(user_record);
 278         }
 279 }
 280
 281 /* UserRecord API */
 282
 283 NMSTATUS_T
 284 nm_user_record_get_status(NMUserRecord * user_record)
 285 {
 286         if (user_record == NULL)
 287                 return (NMSTATUS_T) - 1;
 288
 289         return user_record->status;
 290
 291 }
 292
 293 const char *
 294 nm_user_record_get_status_text(NMUserRecord * user_record)
 295 {
 296         if (user_record == NULL)
 297                 return NULL;
 298
 299         return user_record->status_text;
 300 }
 301
 302 void
 303 nm_user_record_set_dn(NMUserRecord * user_record, const char *dn)
 304 {
 305         if (user_record != NULL && dn != NULL) {
 306                 g_free(user_record->dn);
 307
 308                 user_record->dn = g_strdup(dn);
 309         }
 310 }
 311
 312 const char *
 313 nm_user_record_get_dn(NMUserRecord * user_record)
 314 {
 315         if (user_record == NULL)
 316                 return NULL;
 317
 318         return user_record->dn;
 319 }
 320
 321 void
 322 nm_user_record_set_userid(NMUserRecord * user_record, const char *userid)
 323 {
 324         if (user_record != NULL && userid != NULL) {
 325                 g_free(user_record->cn);
 326
 327                 user_record->cn = g_strdup(userid);
 328         }
 329 }
 330
 331 const char *
 332 nm_user_record_get_userid(NMUserRecord * user_record)
 333 {
 334         if (user_record == NULL)
 335                 return NULL;
 336
 337         return user_record->cn;
 338 }
 339
 340 void
 341 nm_user_record_set_display_id(NMUserRecord * user_record, const char *display_id)
 342 {
 343         if (user_record != NULL && display_id != NULL) {
 344                 g_free(user_record->display_id);
 345
 346                 user_record->display_id = g_strdup(display_id);
 347         }
 348 }
 349
 350 const char *
 351 nm_user_record_get_display_id(NMUserRecord * user_record)
 352 {
 353         if (user_record == NULL)
 354                 return NULL;
 355
 356         if (user_record->display_id == NULL) {
 357                 user_record->display_id = nm_typed_to_dotted(user_record->dn);
 358         }
 359
 360         return user_record->display_id;
 361 }
 362
 363 const char *
 364 nm_user_record_get_full_name(NMUserRecord * user_record)
 365 {
 366         if (user_record == NULL)
 367                 return NULL;
 368
 369         if (user_record->full_name == NULL) {
 370                 if (user_record->fname && user_record->lname) {
 371                         user_record->full_name = g_strdup_printf("%s %s",
 372                                                                                                          user_record->fname,
 373                                                                                                          user_record->lname);
 374
 375                 }
 376         }
 377
 378         return user_record->full_name;
 379 }
 380
 381 const char *
 382 nm_user_record_get_first_name(NMUserRecord * user_record)
 383 {
 384         if (user_record == NULL)
 385                 return NULL;
 386
 387         return user_record->fname;
 388
 389 }
 390
 391 const char *
 392 nm_user_record_get_last_name(NMUserRecord * user_record)
 393 {
 394         if (user_record == NULL)
 395                 return NULL;
 396
 397         return user_record->lname;
 398 }
 399
 400 gpointer
 401 nm_user_record_get_data(NMUserRecord * user_record)
 402 {
 403         if (user_record == NULL)
 404                 return NULL;
 405
 406         return user_record->data;
 407 }
 408
 409 void
 410 nm_user_record_set_data(NMUserRecord * user_record, gpointer data)
 411 {
 412         if (user_record == NULL)
 413                 return;
 414
 415         user_record->data = data;
 416 }
 417
 418 void
 419 nm_user_record_set_status(NMUserRecord * user_record,
 420                                                   int status, const char *text)
 421 {
 422         if (user_record == NULL)
 423                 return;
 424
 425         user_record->status = status;
 426
 427         g_free(user_record->status_text);
 428         user_record->status_text = NULL;
 429
 430         if (text)
 431                 user_record->status_text = g_strdup(text);
 432 }
 433
 434 gboolean
 435 nm_user_record_get_auth_attr(NMUserRecord *user_record)
 436 {
 437         if (user_record == NULL)
 438                 return FALSE;
 439
 440         return user_record->auth_attr;
 441 }
 442
 443 int
 444 nm_user_record_get_property_count(NMUserRecord * user_record)
 445 {
 446         NMField *locate, *fields;
 447
 448         int count = 0;
 449
 450         if (user_record && user_record->fields) {
 451                 locate = nm_locate_field(NM_A_FA_INFO_DISPLAY_ARRAY,
 452                                                                  (NMField *) user_record->fields);
 453                 if (locate && (fields = (NMField *) (locate->ptr_value))) {
 454                         count = (int) nm_count_fields(fields);
 455                 }
 456         }
 457         return count;
 458 }
 459
 460 NMProperty *
 461 nm_user_record_get_property(NMUserRecord * user_record, int index)
 462 {
 463         NMProperty *property = NULL;
 464         NMField *field = NULL, *fields, *locate;
 465
 466         if (user_record && user_record->fields) {
 467                 locate = nm_locate_field(NM_A_FA_INFO_DISPLAY_ARRAY,
 468                                                                  (NMField *) user_record->fields);
 469                 if (locate && (fields = (NMField *) (locate->ptr_value))) {
 470                         int max = nm_count_fields(fields);
 471
 472                         if (index < max) {
 473                                         field = &fields[index];
 474                                         if (field && field->tag && field->ptr_value) {
 475                                                 property = g_new0(NMProperty, 1);
 476                                                 property->tag = g_strdup(field->tag);
 477                                                 property->value = _get_attribute_value(field);
 478                                         }
 479                         }
 480                 }
 481         }
 482
 483         return property;
 484 }
 485
 486 void
 487 nm_release_property(NMProperty * property)
 488 {
 489         if (property) {
 490                 g_free(property->tag);
 491
 492                 g_free(property->value);
 493
 494                 g_free(property);
 495         }
 496 }
 497
 498 const char *
 499 nm_property_get_tag(NMProperty * property)
 500 {
 501         if (property)
 502                 return property->tag;
 503         else
 504                 return NULL;
 505 }
 506
 507 const char *
 508 nm_property_get_value(NMProperty * property)
 509 {
 510         if (property)
 511                 return property->value;
 512         else
 513                 return NULL;
 514 }