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 != NULL) &&
  85                         ((tmp->type == NMFIELD_TYPE_UTF8) ||
  86                         (tmp->type == NMFIELD_TYPE_DN))) {
  87
  88                         value = (char *)tmp->ptr_value;
  89
  90                 } else {
  91                         return NULL;
  92                 }
  93
  94         } else {
  95                 return NULL;
  96         }
  97
  98         return g_strdup(value);
  99 }
 100 /*
 101  * This creates a user_record for the reference list the
 102  * field array that is passed in should be a
 103  * NM_A_FA_USER_DETAILS array.
 104  */
 105 NMUserRecord *
 106 nm_create_user_record_from_fields(NMField * details)
 107 {
 108         NMUserRecord *user_record;
 109         NMField *field, *fields = details;
 110
 111         if (details == NULL) {
 112                 return NULL;
 113         }
 114
 115         if (details->type == NMFIELD_TYPE_ARRAY) {
 116                 if (details->ptr_value == NULL)
 117                         return NULL;
 118                 fields = (NMField *) details->ptr_value;
 119         }
 120
 121         user_record = nm_create_user_record();
 122
 123         if ((field = nm_locate_field(NM_A_SZ_AUTH_ATTRIBUTE, fields))) {
 124
 125                 if (field->ptr_value) {
 126                         user_record->display_id = _get_attribute_value(field);
 127                         user_record->auth_attr = TRUE;
 128                 }
 129         }
 130
 131         if ((field = nm_locate_field(NM_A_SZ_DN, fields))) {
 132
 133                 if (field->ptr_value) {
 134                         user_record->dn = _get_attribute_value(field);
 135                 }
 136         }
 137
 138         if ((field = nm_locate_field("CN", fields))) {
 139
 140                 if (field->ptr_value) {
 141                         user_record->cn = _get_attribute_value(field);
 142                 }
 143         }
 144
 145         if ((field = nm_locate_field("Given Name", fields))) {
 146
 147                 if (field->ptr_value) {
 148                         user_record->fname = _get_attribute_value(field);
 149                 }
 150         }
 151
 152         if ((field = nm_locate_field("Surname", fields))) {
 153
 154                 if (field->ptr_value) {
 155                         user_record->lname = _get_attribute_value(field);
 156                 }
 157         }
 158
 159         if ((field = nm_locate_field("Full Name", fields))) {
 160
 161                 if (field->ptr_value) {
 162                         user_record->full_name = _get_attribute_value(field);
 163                 }
 164         }
 165
 166         if ((field = nm_locate_field(NM_A_SZ_STATUS, fields))) {
 167
 168                 if (field->ptr_value)
 169                         user_record->status = atoi((char *) field->ptr_value);
 170
 171         }
 172
 173         if ((field = nm_locate_field(NM_A_SZ_MESSAGE_BODY, fields))) {
 174
 175                 if (field->ptr_value)
 176                         user_record->status_text = g_strdup((char *) field->ptr_value);
 177
 178         }
 179
 180         user_record->fields = nm_copy_field_array(fields);
 181
 182         return user_record;
 183 }
 184
 185 void
 186 nm_user_record_copy(NMUserRecord * dest, NMUserRecord * src)
 187 {
 188         if (dest == NULL || src == NULL)
 189                 return;
 190
 191         dest->status = src->status;
 192
 193         /* Copy status text */
 194         g_free(dest->status_text);
 195         dest->status_text = NULL;
 196
 197         if (src->status_text)
 198                 dest->status_text = g_strdup(src->status_text);
 199
 200         /* Copy DN */
 201         g_free(dest->dn);
 202         dest->dn = NULL;
 203
 204         if (src->dn)
 205                 dest->dn = g_strdup(src->dn);
 206
 207         /* Copy CN */
 208         g_free(dest->cn);
 209         dest->cn = NULL;
 210
 211         if (src->cn)
 212                 dest->cn = g_strdup(src->cn);
 213
 214         /* Copy display id */
 215         g_free(dest->display_id);
 216         dest->display_id = NULL;
 217
 218         if (src->display_id)
 219                 dest->display_id = g_strdup(src->display_id);
 220
 221         /* Copy first name */
 222         g_free(dest->fname);
 223         dest->fname = NULL;
 224
 225         if (src->fname)
 226                 dest->fname = g_strdup(src->fname);
 227
 228         /* Copy last name */
 229         g_free(dest->lname);
 230         dest->lname = NULL;
 231
 232         if (src->lname)
 233                 dest->lname = g_strdup(src->lname);
 234
 235         /* Copy full name */
 236         g_free(dest->full_name);
 237         dest->full_name = NULL;
 238
 239         if (src->full_name)
 240                 dest->full_name = g_strdup(src->full_name);
 241
 242         /* Copy fields */
 243         if (src->fields) {
 244
 245                 if (dest->fields) {
 246                         nm_free_fields(&dest->fields);
 247                 }
 248
 249                 dest->fields = nm_copy_field_array(src->fields);
 250         }
 251
 252         /* Copy data */
 253         dest->data = src->data;
 254 }
 255
 256 void
 257 nm_user_record_add_ref(NMUserRecord * user_record)
 258 {
 259         if (user_record)
 260                 user_record->ref_count++;
 261 }
 262
 263 void
 264 nm_release_user_record(NMUserRecord * user_record)
 265 {
 266         if (--(user_record->ref_count) == 0) {
 267
 268                 purple_debug(PURPLE_DEBUG_INFO, "novell",
 269                                    "Releasing user_record, total=%d\n", --count);
 270
 271                 g_free(user_record->dn);
 272                 g_free(user_record->cn);
 273                 g_free(user_record->display_id);
 274                 g_free(user_record->fname);
 275                 g_free(user_record->lname);
 276                 g_free(user_record->full_name);
 277                 g_free(user_record->status_text);
 278
 279                 nm_free_fields(&user_record->fields);
 280
 281                 g_free(user_record);
 282         }
 283 }
 284
 285 /* UserRecord API */
 286
 287 NMSTATUS_T
 288 nm_user_record_get_status(NMUserRecord * user_record)
 289 {
 290         if (user_record == NULL)
 291                 return (NMSTATUS_T) - 1;
 292
 293         return user_record->status;
 294
 295 }
 296
 297 const char *
 298 nm_user_record_get_status_text(NMUserRecord * user_record)
 299 {
 300         if (user_record == NULL)
 301                 return NULL;
 302
 303         return user_record->status_text;
 304 }
 305
 306 void
 307 nm_user_record_set_dn(NMUserRecord * user_record, const char *dn)
 308 {
 309         if (user_record != NULL && dn != NULL) {
 310                 g_free(user_record->dn);
 311
 312                 user_record->dn = g_strdup(dn);
 313         }
 314 }
 315
 316 const char *
 317 nm_user_record_get_dn(NMUserRecord * user_record)
 318 {
 319         if (user_record == NULL)
 320                 return NULL;
 321
 322         return user_record->dn;
 323 }
 324
 325 void
 326 nm_user_record_set_userid(NMUserRecord * user_record, const char *userid)
 327 {
 328         if (user_record != NULL && userid != NULL) {
 329                 g_free(user_record->cn);
 330
 331                 user_record->cn = g_strdup(userid);
 332         }
 333 }
 334
 335 const char *
 336 nm_user_record_get_userid(NMUserRecord * user_record)
 337 {
 338         if (user_record == NULL)
 339                 return NULL;
 340
 341         return user_record->cn;
 342 }
 343
 344 void
 345 nm_user_record_set_display_id(NMUserRecord * user_record, const char *display_id)
 346 {
 347         if (user_record != NULL && display_id != NULL) {
 348                 g_free(user_record->display_id);
 349
 350                 user_record->display_id = g_strdup(display_id);
 351         }
 352 }
 353
 354 const char *
 355 nm_user_record_get_display_id(NMUserRecord * user_record)
 356 {
 357         if (user_record == NULL)
 358                 return NULL;
 359
 360         if (user_record->display_id == NULL) {
 361                 user_record->display_id = nm_typed_to_dotted(user_record->dn);
 362         }
 363
 364         return user_record->display_id;
 365 }
 366
 367 const char *
 368 nm_user_record_get_full_name(NMUserRecord * user_record)
 369 {
 370         if (user_record == NULL)
 371                 return NULL;
 372
 373         if (user_record->full_name == NULL) {
 374                 if (user_record->fname && user_record->lname) {
 375                         user_record->full_name = g_strdup_printf("%s %s",
 376                                                                                                          user_record->fname,
 377                                                                                                          user_record->lname);
 378
 379                 }
 380         }
 381
 382         return user_record->full_name;
 383 }
 384
 385 const char *
 386 nm_user_record_get_first_name(NMUserRecord * user_record)
 387 {
 388         if (user_record == NULL)
 389                 return NULL;
 390
 391         return user_record->fname;
 392
 393 }
 394
 395 const char *
 396 nm_user_record_get_last_name(NMUserRecord * user_record)
 397 {
 398         if (user_record == NULL)
 399                 return NULL;
 400
 401         return user_record->lname;
 402 }
 403
 404 gpointer
 405 nm_user_record_get_data(NMUserRecord * user_record)
 406 {
 407         if (user_record == NULL)
 408                 return NULL;
 409
 410         return user_record->data;
 411 }
 412
 413 void
 414 nm_user_record_set_data(NMUserRecord * user_record, gpointer data)
 415 {
 416         if (user_record == NULL)
 417                 return;
 418
 419         user_record->data = data;
 420 }
 421
 422 void
 423 nm_user_record_set_status(NMUserRecord * user_record,
 424                                                   int status, const char *text)
 425 {
 426         if (user_record == NULL)
 427                 return;
 428
 429         user_record->status = status;
 430
 431         g_free(user_record->status_text);
 432         user_record->status_text = NULL;
 433
 434         if (text)
 435                 user_record->status_text = g_strdup(text);
 436 }
 437
 438 gboolean
 439 nm_user_record_get_auth_attr(NMUserRecord *user_record)
 440 {
 441         if (user_record == NULL)
 442                 return FALSE;
 443
 444         return user_record->auth_attr;
 445 }
 446
 447 int
 448 nm_user_record_get_property_count(NMUserRecord * user_record)
 449 {
 450         NMField *locate, *fields;
 451
 452         int count = 0;
 453
 454         if (user_record && user_record->fields) {
 455                 locate = nm_locate_field(NM_A_FA_INFO_DISPLAY_ARRAY,
 456                                                                  (NMField *) user_record->fields);
 457                 if (locate && (fields = (NMField *) (locate->ptr_value))) {
 458                         count = (int) nm_count_fields(fields);
 459                 }
 460         }
 461         return count;
 462 }
 463
 464 NMProperty *
 465 nm_user_record_get_property(NMUserRecord * user_record, int index)
 466 {
 467         NMProperty *property = NULL;
 468         NMField *field = NULL, *fields, *locate;
 469
 470         if (user_record && user_record->fields) {
 471                 locate = nm_locate_field(NM_A_FA_INFO_DISPLAY_ARRAY,
 472                                                                  (NMField *) user_record->fields);
 473                 if (locate && (fields = (NMField *) (locate->ptr_value))) {
 474                         int max = nm_count_fields(fields);
 475
 476                         if (index < max) {
 477                                 if (user_record) {
 478                                         field = &fields[index];
 479                                         if (field && field->tag && field->ptr_value) {
 480                                                 property = g_new0(NMProperty, 1);
 481                                                 property->tag = g_strdup(field->tag);
 482                                                 property->value = _get_attribute_value(field);
 483                                         }
 484                                 }
 485                         }
 486                 }
 487         }
 488
 489         return property;
 490 }
 491
 492 void
 493 nm_release_property(NMProperty * property)
 494 {
 495         if (property) {
 496                 g_free(property->tag);
 497
 498                 g_free(property->value);
 499
 500                 g_free(property);
 501         }
 502 }
 503
 504 const char *
 505 nm_property_get_tag(NMProperty * property)
 506 {
 507         if (property)
 508                 return property->tag;
 509         else
 510                 return NULL;
 511 }
 512
 513 const char *
 514 nm_property_get_value(NMProperty * property)
 515 {
 516         if (property)
 517                 return property->value;
 518         else
 519                 return NULL;
 520 }