• Skip to content
  • Skip to link menu
KDE 4.2 API Reference
  • KDE API Reference
  • KDE-PIM Libraries
  • Sitemap
  • Contact Us
 

KLDAP Library

ber.cpp

00001 /*
00002   This file is part of libkldap.
00003   Copyright (c) 2004-2006 Szombathelyi György <gyurco@freemail.hu>
00004 
00005   This library is free software; you can redistribute it and/or
00006   modify it under the terms of the GNU Library General  Public
00007   License as published by the Free Software Foundation; either
00008   version 2 of the License, or (at your option) any later version.
00009 
00010   This library is distributed in the hope that it will be useful,
00011   but WITHOUT ANY WARRANTY; without even the implied warranty of
00012   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013   Library General Public License for more details.
00014 
00015   You should have received a copy of the GNU Library General Public License
00016   along with this library; see the file COPYING.LIB.  If not, write to
00017   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00018   Boston, MA 02110-1301, USA.
00019 */
00020 
00021 #include "ber.h"
00022 #include "kldap_config.h"
00023 
00024 #include <kdebug.h>
00025 
00026 #include <QtCore/QList>
00027 #include <qvarlengtharray.h>
00028 
00029 #include <cstdarg>
00030 
00031 #ifdef LDAP_FOUND
00032 
00033 #ifdef Q_OS_SOLARIS //krazy:exclude=cpp
00034 #define BC31 1
00035 #endif
00036 
00037 #include <lber.h>
00038 #include <ldap.h>
00039 
00040 #ifndef LBER_USE_DER
00041 #define LBER_USE_DER 1
00042 #endif
00043 
00044 #ifndef HAVE_BER_MEMFREE
00045 #define ber_memfree(x) ldap_memfree(x)
00046 #endif
00047 
00048 #endif
00049 
00050 using namespace KLDAP;
00051 
00052 class Ber::BerPrivate
00053 {
00054   public:
00055 #ifdef LDAP_FOUND
00056     BerElement *mBer;
00057 #endif
00058 };
00059 
00060 #ifdef LDAP_FOUND
00061 Ber::Ber()
00062  : d( new BerPrivate )
00063 {
00064   d->mBer = ber_alloc_t( LBER_USE_DER );
00065   Q_ASSERT( d->mBer );
00066 }
00067 
00068 Ber::Ber( const QByteArray &value )
00069  : d( new BerPrivate )
00070 {
00071   struct berval bv;
00072   bv.bv_val = (char*) value.data();
00073   bv.bv_len = value.size();
00074   d->mBer = ber_init( &bv );
00075   Q_ASSERT( d->mBer );
00076 }
00077 
00078 Ber::~Ber()
00079 {
00080   ber_free( d->mBer, 1 );
00081   delete d;
00082 }
00083 
00084 Ber::Ber( const Ber &that )
00085   : d( new BerPrivate )
00086 {
00087   struct berval *bv;
00088   if ( ber_flatten( that.d->mBer, &bv ) == 0 ) {
00089     d->mBer = ber_init( bv );
00090     ber_bvfree( bv );
00091   }
00092 }
00093 
00094 Ber &Ber::operator=( const Ber &that )
00095 {
00096   if ( this == &that ) {
00097     return *this;
00098   }
00099 
00100   struct berval *bv;
00101   if ( ber_flatten( that.d->mBer, &bv ) == 0 ) {
00102     d->mBer = ber_init( bv );
00103     ber_bvfree( bv );
00104   }
00105   return *this;
00106 }
00107 
00108 QByteArray Ber::flatten() const
00109 {
00110   QByteArray ret;
00111   struct berval *bv;
00112   if ( ber_flatten( d->mBer, &bv ) == 0 ) {
00113     ret = QByteArray( bv->bv_val, bv->bv_len );
00114     ber_bvfree( bv );
00115   }
00116   return ret;
00117 }
00118 
00119 int Ber::printf( const QString &format, ... )
00120 {
00121   char fmt[2];
00122   va_list args;
00123   va_start ( args, format );
00124   fmt[1] = '\0';
00125 
00126   int i = 0, ret = 0;
00127   while ( i < format.length() ) {
00128     fmt[0] = format[i].toLatin1();
00129     i++;
00130     switch ( fmt[0] ) {
00131       case 'b':
00132       case 'e':
00133       case 'i':
00134         {
00135           ber_int_t v = va_arg( args, int );
00136           ret = ber_printf( d->mBer, fmt, v );
00137           break;
00138         }
00139       case 'B':
00140         {
00141           //FIXME: QBitArray vould be logical, but how to access the bits?
00142           QByteArray *B = va_arg( args, QByteArray * );
00143           int Bc = va_arg( args, int );
00144           ret = ber_printf( d->mBer, fmt, B->data(), Bc );
00145           break;
00146         }
00147       case 'o':
00148         {
00149           QByteArray *o = va_arg( args, QByteArray * );
00150           ret = ber_printf( d->mBer, fmt, o->data(), o->size() );
00151           break;
00152         }
00153       case 'O':
00154         {
00155           QByteArray *O = va_arg( args, QByteArray * );
00156           struct berval bv;
00157           bv.bv_val = (char*) O->data();
00158           bv.bv_len = O->size();
00159           ret = ber_printf( d->mBer, fmt, &bv );
00160           break;
00161         }
00162         break;
00163       case 's':
00164         {
00165           QByteArray *s = va_arg( args, QByteArray * );
00166           ret = ber_printf( d->mBer, fmt, s->data() );
00167           break;
00168         }
00169         break;
00170       case 't':
00171         {
00172           unsigned int t = va_arg( args, unsigned int );
00173           ret = ber_printf( d->mBer, fmt, t );
00174           break;
00175         }
00176         break;
00177       case 'v':
00178         {
00179           QList<QByteArray> *v = va_arg( args, QList<QByteArray> * );
00180           QVarLengthArray<const char *> l( v->count()+1 );
00181           int j;
00182           for ( j = 0; j < v->count(); j++ ) {
00183             l[j] = v->at(j).data();
00184           }
00185           l[j] = 0;
00186           ret = ber_printf( d->mBer, fmt, l.data() );
00187           break;
00188         }
00189       case 'V':
00190         {
00191           QList<QByteArray> *V = va_arg( args, QList<QByteArray> * );
00192           QVarLengthArray<struct berval *> bv ( V->count()+1 );
00193           QVarLengthArray<struct berval> bvs( V->count( ) );
00194           int j;
00195           for ( j = 0; j < V->count(); j++ ) {
00196             bvs[j].bv_val = (char *) V->at(j).data();
00197             bvs[j].bv_len = V->at(j).size();
00198             bv[j] = &bvs[j];
00199           }
00200           bv[V->count()] = 0;
00201           ret = ber_printf( d->mBer, fmt, bv.data() );
00202           break;
00203         }
00204       case 'n':
00205       case '{':
00206       case '}':
00207       case '[':
00208       case ']':
00209         ret = ber_printf( d->mBer, fmt );
00210         break;
00211       default:
00212         kWarning() << "Invalid BER format parameter: '" << fmt << "'";
00213         ret = -1;
00214     }
00215     kDebug() << "ber_printf format:" << fmt << "ret:" << ret;
00216     if ( ret == -1 ) {
00217       break;
00218     }
00219   }
00220   va_end( args );
00221   return ret;
00222 }
00223 
00224 int Ber::scanf( const QString &format, ... )
00225 {
00226   char fmt[2];
00227   va_list args;
00228   va_start ( args, format );
00229   fmt[1] = '\0';
00230 
00231   int i = 0, ret = 0;
00232   while ( i < format.length() ) {
00233     fmt[0] = format[i].toLatin1();
00234     i++;
00235     switch ( fmt[0] ) {
00236       case 'l':
00237       case 'b':
00238       case 'e':
00239       case 'i':
00240         {
00241           int *v = va_arg( args, int * );
00242           ret = ber_scanf( d->mBer, fmt, v );
00243           break;
00244         }
00245       case 'B':
00246         {
00247           //FIXME: QBitArray vould be logical, but how to access the bits?
00248           QByteArray *B = va_arg( args, QByteArray * );
00249           int *Bc = va_arg( args, int * );
00250           char *c;
00251           ret = ber_scanf( d->mBer, fmt, &c, Bc );
00252           if ( ret != -1 ) {
00253             *B = QByteArray( c, ( *Bc + 7 ) / 8 );
00254             ber_memfree( c );
00255           }
00256           break;
00257         }
00258       case 'o':
00259         {
00260           QByteArray *o = va_arg( args, QByteArray * );
00261           struct berval bv;
00262           ret = ber_scanf( d->mBer, fmt, &bv );
00263           if ( ret != -1 ) {
00264             *o = QByteArray( bv.bv_val, bv.bv_len );
00265             ber_memfree( bv.bv_val );
00266           }
00267           break;
00268         }
00269       case 'O':
00270         {
00271           QByteArray *O = va_arg( args, QByteArray * );
00272           struct berval *bv;
00273           ret = ber_scanf( d->mBer, fmt, &bv );
00274           if ( ret != -1 ) {
00275             *O = QByteArray( bv->bv_val, bv->bv_len );
00276             ber_bvfree( bv );
00277           }
00278           break;
00279         }
00280         break;
00281       case 'm': //the same as 'O', just *bv should not be freed.
00282         {
00283           QByteArray *m = va_arg( args, QByteArray * );
00284           struct berval *bv;
00285           ret = ber_scanf( d->mBer, fmt, &bv );
00286           if ( ret != -1 ) {
00287             *m = QByteArray( bv->bv_val, bv->bv_len );
00288           }
00289           break;
00290         }
00291       case 'a':
00292         {
00293           QByteArray *a = va_arg( args, QByteArray * );
00294           char *c;
00295           ret = ber_scanf( d->mBer, fmt, &c );
00296           if ( ret != -1 ) {
00297             *a = QByteArray( c );
00298             ber_memfree( c );
00299           }
00300           break;
00301         }
00302 
00303       case 's':
00304         {
00305           QByteArray *s = va_arg( args, QByteArray * );
00306           char buf[255];
00307           ber_len_t l = sizeof( buf );
00308           ret = ber_scanf( d->mBer, fmt, &buf, &l );
00309           if ( ret != -1 ) {
00310             *s = QByteArray( buf, l );
00311           }
00312           break;
00313         }
00314       case 't':
00315       case 'T':
00316         {
00317           unsigned int *t = va_arg( args, unsigned int * );
00318           ret = ber_scanf( d->mBer, fmt, t );
00319           break;
00320         }
00321         break;
00322       case 'v':
00323         {
00324           QList<QByteArray> *v = va_arg( args, QList<QByteArray> * );
00325           char **c, **c2;
00326           ret = ber_scanf( d->mBer, fmt, &c );
00327           if ( ret != -1 && c ) {
00328             c2 = c;
00329             while ( *c ) {
00330               v->append( QByteArray( *c ) );
00331               ber_memfree( *c );
00332               c++;
00333             }
00334             ber_memfree( (char *) c2 );
00335           }
00336           break;
00337         }
00338       case 'V':
00339         {
00340           QList<QByteArray> *v = va_arg( args, QList<QByteArray> * );
00341           struct berval **bv, **bv2;
00342           ret = ber_scanf( d->mBer, fmt, &bv );
00343           if ( ret != -1 && bv ) {
00344             bv2 = bv;
00345             while ( *bv ) {
00346               v->append( QByteArray( (*bv)->bv_val, (*bv)->bv_len ) );
00347               bv++;
00348             }
00349             ber_bvecfree( bv2 );
00350           }
00351           break;
00352         }
00353       case 'x':
00354       case 'n':
00355       case '{':
00356       case '}':
00357       case '[':
00358       case ']':
00359         ret = ber_scanf( d->mBer, fmt );
00360         break;
00361       default:
00362         kWarning() << "Invalid BER format parameter: '" << fmt << "'";
00363         ret = -1;
00364     }
00365 
00366     kDebug() << "ber_scanf format:" << fmt << "ret:" << ret;
00367     if ( ret == -1 ) {
00368       break;
00369     }
00370 
00371   }
00372   va_end( args );
00373   return ret;
00374 }
00375 
00376 unsigned int Ber::peekTag( int &size )
00377 {
00378   unsigned int ret;
00379   ber_len_t len;
00380   ret = ber_peek_tag( d->mBer, &len );
00381   size = len;
00382   return ret;
00383 }
00384 
00385 unsigned int Ber::skipTag( int &size )
00386 {
00387   unsigned int ret;
00388   ber_len_t len;
00389   ret = ber_skip_tag( d->mBer, &len );
00390   size = len;
00391   return ret;
00392 }
00393 #else
00394 
00395 Ber::Ber()
00396  : d( new BerPrivate )
00397 {
00398   kError() << "LDAP support not compiled";
00399 }
00400 
00401 Ber::Ber( const QByteArray & )
00402  : d( new BerPrivate )
00403 {
00404   kError() << "LDAP support not compiled";
00405 }
00406 
00407 Ber::~Ber()
00408 {
00409   delete d;
00410 }
00411 
00412 Ber::Ber( const Ber & )
00413  : d( new BerPrivate )
00414 {
00415   kError() << "LDAP support not compiled";
00416 }
00417 
00418 Ber &Ber::operator=( const Ber &that )
00419 {
00420   if ( this == &that ) {
00421     return *this;
00422   }
00423   kError() << "LDAP support not compiled";
00424   return *this;
00425 }
00426 
00427 QByteArray Ber::flatten() const
00428 {
00429   kError() << "LDAP support not compiled";
00430   return QByteArray();
00431 }
00432 
00433 int Ber::printf( const QString &format, ... )
00434 {
00435   Q_UNUSED( format );
00436   kError() << "LDAP support not compiled";
00437   return -1;
00438 }
00439 
00440 int Ber::scanf( const QString &format, ... )
00441 {
00442   Q_UNUSED( format );
00443   kError() << "LDAP support not compiled";
00444   return -1;
00445 }
00446 
00447 unsigned int Ber::peekTag( int &size )
00448 {
00449   Q_UNUSED( size );
00450   kError() << "LDAP support not compiled";
00451   return -1;
00452 }
00453 
00454 unsigned int Ber::skipTag( int &size )
00455 {
00456   Q_UNUSED( size );
00457   kError() << "LDAP support not compiled";
00458   return -1;
00459 }
00460 
00461 #endif

KLDAP Library

Skip menu "KLDAP Library"
  • Main Page
  • Alphabetical List
  • Class List
  • File List
  • Class Members
  • Related Pages

KDE-PIM Libraries

Skip menu "KDE-PIM Libraries"
  • akonadi
  • kabc
  • kblog
  • kcal
  • kimap
  • kioslave
  •   imap4
  •   mbox
  • kldap
  • kmime
  • kpimidentities
  •   richtextbuilders
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Generated for KDE-PIM Libraries by doxygen 1.5.8
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal