src/vbase.cc

   1 ///
   2 /// \file       vbase.cc
   3 ///             vformat support routines in base class
   4 ///
   5
   6 /*
   7     Copyright (C) 2006-2012, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #include "vbase.h"
  23 //#include "trace.h"
  24 #include "vformat.h"            // comes from opensync, but not a public header yet
  25 #include "tzwrapper.h"
  26 #include "r_contact.h"          // for CategoryList
  27 #include <stdio.h>
  28 #include <stdarg.h>
  29 #include <stdint.h>
  30 #include <string.h>
  31 #include <glib.h>
  32 #include <sstream>
  33
  34 using namespace std;
  35
  36 namespace Barry { namespace Sync {
  37
  38 //////////////////////////////////////////////////////////////////////////////
  39 // vTimeConverter
  40
  41 std::string vTimeConverter::unix2vtime(const time_t *timestamp)
  42 {
  43         struct tm split;
  44         if( !gmtime_r(timestamp, &split) ) {
  45                 ostringstream oss;
  46                 oss << "gmtime_r() failed on time_t of ";
  47                 if( timestamp )
  48                         oss << *timestamp;
  49                 else
  50                         oss << "(null pointer)";
  51                 throw Barry::ConvertError(oss.str());
  52         }
  53
  54         return tm_to_iso(&split, true);
  55 }
  56
  57 time_t vTimeConverter::vtime2unix(const char *vtime)
  58 {
  59         return TzWrapper::iso_mktime(vtime);
  60 }
  61
  62 //
  63 // The following implementation is taken from opensync's
  64 // opensync_time.c implementation with the following copyright
  65 // notices at the top as of July 2010:
  66 //
  67 //  * Copyright (C) 2004-2005  Armin Bauer <armin.bauer@opensync.org>
  68 //  * Copyright (C) 2006-2008 Daniel Gollub <gollub@b1-systems.de>
  69 //  * Copyright (C) 2007 Chris Frey <cdfrey@netdirect.ca>
  70 //
  71 // License: LGPL 2.1 or later
  72 //
  73 int vTimeConverter::alarmduration2sec(const char *alarm)
  74 {
  75         int i, secs, digits = 0;
  76         int is_digit = 0;
  77         int sign = 1;   // when ical stamp doesn't start with '-' => seconds after event
  78         int days = 0, weeks = 0, hours = 0, minutes = 0, seconds = 0;
  79         int len = strlen(alarm);
  80
  81         for (i=0; i < len; i++) {
  82
  83                 switch (alarm[i]) {
  84                 case '-':
  85                         sign = -1; // seconds before event - change the sign
  86                 case 'P':
  87                 case 'T':
  88                         is_digit = 0;
  89                         break;
  90                 case 'W':
  91                         is_digit = 0;
  92                         weeks = digits;
  93                         break;
  94                 case 'D':
  95                         is_digit = 0;
  96                         days = digits;
  97                         break;
  98                 case 'H':
  99                         is_digit = 0;
 100                         hours = digits;
 101                         break;
 102                 case 'M':
 103                         is_digit = 0;
 104                         minutes = digits;
 105                         break;
 106                 case 'S':
 107                         is_digit = 0;
 108                         seconds = digits;
 109                         break;
 110                 case '0':
 111                 case '1':
 112                 case '2':
 113                 case '3':
 114                 case '4':
 115                 case '5':
 116                 case '6':
 117                 case '7':
 118                 case '8':
 119                 case '9':
 120                         if (is_digit)
 121                                 break;
 122
 123                         if (sscanf((char*)(alarm+i),"%d",&digits) == EOF)
 124                                 return -1;
 125
 126                         is_digit = 1;
 127                         break;
 128                 }
 129         }
 130
 131         secs = (weeks * 7 * 24 * 3600) + (days * 24 * 3600) + (hours * 3600) + (minutes * 60) + seconds;
 132
 133         secs = secs * sign;     // change sign if the alarm is in seconds before event (leading '-')
 134
 135         return secs;
 136
 137 }
 138
 139
 140 //////////////////////////////////////////////////////////////////////////////
 141 // vAttr
 142
 143 std::string vAttr::GetName()
 144 {
 145         std::string ret;
 146
 147         if( !m_attr )
 148                 return ret;
 149
 150         const char *name = b_vformat_attribute_get_name(m_attr);
 151         if( name )
 152                 ret = name;
 153         return ret;
 154 }
 155
 156 std::string vAttr::GetValue(int nth)
 157 {
 158         std::string ret;
 159         const char *value = 0;
 160
 161         if( m_attr ) {
 162                 if( b_vformat_attribute_is_single_valued(m_attr) ) {
 163                         if( nth == 0 )
 164                                 value = b_vformat_attribute_get_value(m_attr);
 165                 }
 166                 else {
 167                         value = b_vformat_attribute_get_nth_value(m_attr, nth);
 168                 }
 169         }
 170
 171         if( value )
 172                 ret = value;
 173
 174         return ret;
 175 }
 176
 177 std::string vAttr::GetDecodedValue()
 178 {
 179         std::string ret;
 180         GString *value = NULL;
 181
 182         if( m_attr ) {
 183                 if( b_vformat_attribute_is_single_valued(m_attr) ) {
 184                         value = b_vformat_attribute_get_value_decoded(m_attr);
 185                 }
 186         }
 187
 188         if( value )
 189                 ret.assign(value->str, value->len);
 190
 191         return ret;
 192 }
 193
 194 std::string vAttr::GetParam(const char *name, int nth)
 195 {
 196         std::string ret;
 197
 198         if( !m_attr )
 199                 return ret;
 200
 201         b_VFormatParam *param = b_vformat_attribute_find_param(m_attr, name, 0);
 202         if( !param )
 203                 return ret;
 204
 205         const char *value = b_vformat_attribute_param_get_nth_value(param, nth);
 206         if( value )
 207                 ret = value;
 208
 209         return ret;
 210 }
 211
 212 /// Does an exhaustive search through the attribute, searching for all
 213 /// param values that exist for the given name, and returns all values
 214 /// in a comma delimited string.
 215 std::string vAttr::GetAllParams(const char *name)
 216 {
 217         std::string ret;
 218
 219         if( !m_attr )
 220                 return ret;
 221
 222         b_VFormatParam *param = 0;
 223         for( int level = 0;
 224              (param = b_vformat_attribute_find_param(m_attr, name, level));
 225              level++ )
 226         {
 227                 const char *value = 0;
 228                 for( int nth = 0;
 229                      (value = b_vformat_attribute_param_get_nth_value(param, nth));
 230                      nth++ )
 231                 {
 232                         if( ret.size() )
 233                                 ret += ",";
 234                         ret += value;
 235                 }
 236         }
 237
 238         return ret;
 239 }
 240
 241
 242 //////////////////////////////////////////////////////////////////////////////
 243 // vCalendar
 244
 245 vBase::vBase()
 246         : m_format(b_vformat_new())
 247 {
 248 }
 249
 250 vBase::vBase(b_VFormat *format)
 251         : m_format(format)
 252 {
 253         if( !format )
 254                 throw Barry::Error("Cannot construct vBase with null format");
 255 }
 256
 257 vBase::~vBase()
 258 {
 259         if( m_format ) {
 260                 b_vformat_free(m_format);
 261                 m_format = 0;
 262         }
 263 }
 264
 265 void vBase::SetFormat(b_VFormat *format)
 266 {
 267         if( !format )
 268                 throw Barry::Error("Cannot set vBase with null format");
 269
 270         if( m_format ) {
 271                 b_vformat_free(m_format);
 272                 m_format = 0;
 273         }
 274         m_format = format;
 275 }
 276
 277 void vBase::Clear()
 278 {
 279         if( m_format ) {
 280                 b_vformat_free(m_format);
 281                 m_format = b_vformat_new();
 282         }
 283 }
 284
 285 vAttrPtr vBase::NewAttr(const char *name)
 286 {
 287 //      Trace trace("vBase::NewAttr");
 288
 289 //      trace.logf("creating valueless attr: %s", name);
 290
 291         vAttrPtr attr(b_vformat_attribute_new(NULL, name));
 292         if( !attr.Get() )
 293                 throw Barry::ConvertError("resource error allocating vformat attribute");
 294         return attr;
 295 }
 296
 297 vAttrPtr vBase::NewAttr(const char *name, const char *value)
 298 {
 299 //      Trace trace("vBase::NewAttr");
 300
 301 /*
 302 some vCard values are positional (like name), so blank should be allowed...
 303
 304         if( strlen(value) == 0 ) {
 305                 trace.logf("attribute '%s' contains no data, skipping", name);
 306                 return vAttrPtr();
 307         }
 308 */
 309
 310 //      trace.logf("creating attr: %s, %s", name, value);
 311
 312         vAttrPtr attr(b_vformat_attribute_new(NULL, name));
 313         if( !attr.Get() )
 314                 throw ConvertError("resource error allocating vformat attribute");
 315
 316         b_vformat_attribute_add_value(attr.Get(), value);
 317         return attr;
 318 }
 319
 320 void vBase::AddAttr(vAttrPtr attr)
 321 {
 322 //      Trace trace("vBase::AddAttr");
 323
 324         if( !attr.Get() ) {
 325 //              trace.log("attribute contains no data, skipping");
 326                 return;
 327         }
 328
 329         b_vformat_add_attribute(m_format, attr.Extract());
 330 }
 331
 332 void vBase::AddValue(vAttrPtr &attr, const char *value)
 333 {
 334 //      Trace trace("vBase::AddValue");
 335         if( !attr.Get() ) {
 336 //              trace.log("attribute pointer contains no data, skipping");
 337                 return;
 338         }
 339 /*
 340         if( strlen(value) == 0 ) {
 341                 trace.log("attribute value is empty, skipping");
 342                 return;
 343         }
 344 */
 345         b_vformat_attribute_add_value(attr.Get(), value);
 346 }
 347
 348 void vBase::AddEncodedValue(vAttrPtr &attr, b_VFormatEncoding encoding, const char *value, int len)
 349 {
 350 //      Trace trace("vBase::AddValue");
 351         if( !attr.Get() ) {
 352 //              trace.log("attribute pointer contains no data, skipping");
 353                 return;
 354         }
 355
 356         attr.Get()->encoding = encoding;
 357         attr.Get()->encoding_set = TRUE;
 358
 359         b_vformat_attribute_add_value_decoded(attr.Get(), value, len);
 360 }
 361
 362 void vBase::AddParam(vAttrPtr &attr, const char *name, const char *value)
 363 {
 364 //      Trace trace("vBase::AddParam");
 365
 366         if( !attr.Get() ) {
 367 //              trace.log("attribute pointer contains no data, skipping");
 368                 return;
 369         }
 370 /*
 371         if( strlen(value) == 0 ) {
 372                 trace.log("parameter value is empty, skipping");
 373                 return;
 374         }
 375 */
 376
 377         b_VFormatParam *pParam = b_vformat_attribute_param_new(name);
 378         b_vformat_attribute_param_add_value(pParam, value);
 379         b_vformat_attribute_add_param(attr.Get(), pParam);
 380 }
 381
 382 void vBase::AddCategories(const Barry::CategoryList &categories)
 383 {
 384         if( !categories.size() )
 385                 return;
 386
 387         vAttrPtr cat = NewAttr("CATEGORIES");           // RFC 2426, 3.6.1
 388         Barry::CategoryList::const_iterator i = categories.begin();
 389         for( ; i < categories.end(); ++i ) {
 390                 AddValue(cat, i->c_str());
 391         }
 392         AddAttr(cat);
 393 }
 394
 395 std::string vBase::GetAttr(const char *attrname, const char *block)
 396 {
 397 //      Trace trace("vBase::GetAttr");
 398 //      trace.logf("getting attr: %s", attrname);
 399
 400         std::string ret;
 401         const char *value = 0;
 402
 403         bool needs_freeing = false;
 404
 405         b_VFormatAttribute *attr = b_vformat_find_attribute(m_format, attrname, 0, block);
 406         if( attr ) {
 407                 if( b_vformat_attribute_is_single_valued(attr) ) {
 408                         value = b_vformat_attribute_get_value(attr);
 409                         needs_freeing = true;
 410                 }
 411                 else {
 412                         // FIXME, this is hardcoded
 413                         value = b_vformat_attribute_get_nth_value(attr, 0);
 414                 }
 415         }
 416
 417         if( value )
 418                 ret = value;
 419
 420         if( needs_freeing )
 421                 g_free((char *)value);
 422
 423 //      trace.logf("attr value: %s", ret.c_str());
 424         return ret;
 425 }
 426
 427 std::vector<std::string> vBase::GetValueVector(const char *attrname, const char *block)
 428 {
 429 //      Trace trace("vBase::GetValueVector");
 430 //      trace.logf("getting value vector for: %s", attrname);
 431
 432         std::vector<std::string> ret;
 433         const char *value = 0;
 434         bool needs_freeing = false;
 435
 436         b_VFormatAttribute *attr = b_vformat_find_attribute(m_format, attrname, 0, block);
 437         if( attr ) {
 438                 if( b_vformat_attribute_is_single_valued(attr) ) {
 439                         value = b_vformat_attribute_get_value(attr);
 440                         needs_freeing = true;
 441                 } else {
 442                         // nasty, but avoids tweaking vformat.
 443                         int idx = 0;
 444                         do {
 445                                 value = b_vformat_attribute_get_nth_value(attr, idx++);
 446                                 if( value ) {
 447                                         ret.push_back(value);
 448                                 }
 449                         } while( value );
 450                 }
 451         }
 452
 453         if( needs_freeing )
 454                 g_free((char *)value);
 455
 456         return ret;
 457 }
 458
 459 vAttr vBase::GetAttrObj(const char *attrname, int nth, const char *block)
 460 {
 461 //      Trace trace("vBase::GetAttrObj");
 462 //      trace.logf("getting attr: %s", attrname);
 463
 464         return vAttr(b_vformat_find_attribute(m_format, attrname, nth, block));
 465 }
 466
 467 std::vector<std::string> vBase::Tokenize(const std::string& str, const char delim)
 468 {
 469         std::vector<std::string> tokens;
 470         std::string::size_type delimPos = 0, tokenPos = 0, pos = 0;
 471
 472         if( str.length() < 1 ) {
 473                 return tokens;
 474         }
 475
 476         while( 1 ) {
 477                 delimPos = str.find_first_of(delim, pos);
 478                 tokenPos = str.find_first_not_of(delim, pos);
 479
 480                 if( std::string::npos != delimPos ) {
 481                         if( std::string::npos != tokenPos ) {
 482                                 if( tokenPos < delimPos ) {
 483                                         tokens.push_back(str.substr(pos, delimPos-pos));
 484                                 } else {
 485                                         tokens.push_back("");
 486                                 }
 487                         } else {
 488                                 tokens.push_back("");
 489                         }
 490                         pos = delimPos + 1;
 491                 } else {
 492                         if( std::string::npos != tokenPos ){
 493                                 tokens.push_back(str.substr(pos));
 494                         } else {
 495                                 tokens.push_back("");
 496                         }
 497                         break;
 498                 }
 499         }
 500         return tokens;
 501 }
 502
 503 std::string vBase::ToStringList(const std::vector<std::string> &list, const char delim)
 504 {
 505         std::string str;
 506         for( unsigned int idx = 0; idx < list.size(); idx++ ) {
 507                 if( idx ) {
 508                         str += delim;
 509                 }
 510                 str += list[idx];
 511         }
 512         return str;
 513 }
 514
 515 }} // namespace Barry::Sync
 516