• Skip to content
  • Skip to link menu
KDE 4.0 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   public:
00054 #ifdef LDAP_FOUND
00055     BerElement *mBer;
00056 #endif
00057 };
00058 
00059 #ifdef LDAP_FOUND
00060 Ber::Ber()
00061  : d( new BerPrivate )
00062 {
00063   d->mBer = ber_alloc_t( LBER_USE_DER );
00064   Q_ASSERT( d->mBer );
00065 }
00066 
00067 Ber::Ber( const QByteArray &value )
00068  : d( new BerPrivate )
00069 {
00070   struct berval bv;
00071   bv.bv_val = (char*) value.data();
00072   bv.bv_len = value.size();
00073   d->mBer = ber_init( &bv );
00074   Q_ASSERT( d->mBer );
00075 }
00076 
00077 Ber::~Ber()
00078 {
00079   ber_free( d->mBer, 1 );
00080   delete d;
00081 }
00082 
00083 Ber::Ber( const Ber &that )
00084   : d( new BerPrivate )
00085 {
00086   struct berval *bv;
00087   if ( ber_flatten( that.d->mBer, &bv ) == 0 ) {
00088     d->mBer = ber_init( bv );
00089     ber_bvfree( bv );
00090   }
00091 }
00092 
00093 Ber &Ber::operator=( const Ber &that )
00094 {
00095   if ( this == &that ) {
00096     return *this;
00097   }
00098 
00099   struct berval *bv;
00100   if ( ber_flatten( that.d->mBer, &bv ) == 0 ) {
00101     d->mBer = ber_init( bv );
00102     ber_bvfree( bv );
00103   }
00104   return *this;
00105 }
00106 
00107 QByteArray Ber::flatten() const
00108 {
00109   QByteArray ret;
00110   struct berval *bv;
00111   if ( ber_flatten( d->mBer, &bv ) == 0 ) {
00112     ret = QByteArray( bv->bv_val, bv->bv_len );
00113     ber_bvfree( bv );
00114   }
00115   return ret;
00116 }
00117 
00118 int Ber::printf( const QString &format, ... )
00119 {
00120   char fmt[2];
00121   va_list args;
00122   va_start ( args, format );
00123   fmt[1] = '\0';
00124 
00125   int i = 0, ret = 0;
00126   while ( i < format.length() ) {
00127     fmt[0] = format[i].toLatin1();
00128     i++;
00129     switch ( fmt[0] ) {
00130       case 'b':
00131       case 'e':
00132       case 'i':
00133         {
00134           ber_int_t v = va_arg( args, int );
00135           ret = ber_printf( d->mBer, fmt, v );
00136           break;
00137         }
00138       case 'B':
00139         {
00140           //FIXME: QBitArray vould be logical, but how to access the bits?
00141           QByteArray *B = va_arg( args, QByteArray * );
00142           int Bc = va_arg( args, int );
00143           ret = ber_printf( d->mBer, fmt, B->data(), Bc );
00144           break;
00145         }
00146       case 'o':
00147         {
00148           QByteArray *o = va_arg( args, QByteArray * );
00149           ret = ber_printf( d->mBer, fmt, o->data(), o->size() );
00150           break;
00151         }
00152       case 'O':
00153         {
00154           QByteArray *O = va_arg( args, QByteArray * );
00155           struct berval bv;
00156           bv.bv_val = (char*) O->data();
00157           bv.bv_len = O->size();
00158           ret = ber_printf( d->mBer, fmt, &bv );
00159           break;
00160         }
00161         break;
00162       case 's':
00163         {
00164           QByteArray *s = va_arg( args, QByteArray * );
00165           ret = ber_printf( d->mBer, fmt, s->data() );
00166           break;
00167         }
00168         break;
00169       case 't':
00170         {
00171           unsigned int t = va_arg( args, unsigned int );
00172           ret = ber_printf( d->mBer, fmt, t );
00173           break;
00174         }
00175         break;
00176       case 'v':
00177         {
00178           QList<QByteArray> *v = va_arg( args, QList<QByteArray> * );
00179           QVarLengthArray<const char *> l( v->count()+1 );
00180           int j;
00181           for ( j = 0; j < v->count(); j++ ) {
00182             l[j] = v->at(j).data();
00183           }
00184           l[j] = 0;
00185           ret = ber_printf( d->mBer, fmt, l.data() );
00186           break;
00187         }
00188       case 'V':
00189         {
00190           QList<QByteArray> *V = va_arg( args, QList<QByteArray> * );
00191           QVarLengthArray<struct berval *> bv ( V->count()+1 );
00192           QVarLengthArray<struct berval> bvs( V->count( ) );
00193           int j;
00194           for ( j = 0; j < V->count(); j++ ) {
00195             bvs[j].bv_val = (char *) V->at(j).data();
00196             bvs[j].bv_len = V->at(j).size();
00197             bv[j] = &bvs[j];
00198           }
00199           bv[V->count()] = 0;
00200           ret = ber_printf( d->mBer, fmt, bv.data() );
00201           break;
00202         }
00203       case 'n':
00204       case '{':
00205       case '}':
00206       case '[':
00207       case ']':
00208         ret = ber_printf( d->mBer, fmt );
00209         break;
00210       default:
00211         kWarning() << "Invalid BER format parameter: '" << fmt << "'";
00212         ret = -1;
00213     }
00214     kDebug(5322) << "ber_printf format:" << fmt << "ret:" << ret;
00215     if ( ret == -1 ) {
00216       break;
00217     }
00218   }
00219   va_end( args );
00220   return ret;
00221 }
00222 
00223 int Ber::scanf( const QString &format, ... )
00224 {
00225   char fmt[2];
00226   va_list args;
00227   va_start ( args, format );
00228   fmt[1] = '\0';
00229 
00230   int i = 0, ret = 0;
00231   while ( i < format.length() ) {
00232     fmt[0] = format[i].toLatin1();
00233     i++;
00234     switch ( fmt[0] ) {
00235       case 'l':
00236       case 'b':
00237       case 'e':
00238       case 'i':
00239         {
00240           int *v = va_arg( args, int * );
00241           ret = ber_scanf( d->mBer, fmt, v );
00242           break;
00243         }
00244       case 'B':
00245         {
00246           //FIXME: QBitArray vould be logical, but how to access the bits?
00247           QByteArray *B = va_arg( args, QByteArray * );
00248           int *Bc = va_arg( args, int * );
00249           char *c;
00250           ret = ber_scanf( d->mBer, fmt, &c, Bc );
00251           if ( ret != -1 ) {
00252             *B = QByteArray( c, ( *Bc + 7 ) / 8 );
00253             ber_memfree( c );
00254           }
00255           break;
00256         }
00257       case 'o':
00258         {
00259           QByteArray *o = va_arg( args, QByteArray * );
00260           struct berval bv;
00261           ret = ber_scanf( d->mBer, fmt, &bv );
00262           if ( ret != -1 ) {
00263             *o = QByteArray( bv.bv_val, bv.bv_len );
00264             ber_memfree( bv.bv_val );
00265           }
00266           break;
00267         }
00268       case 'O':
00269         {
00270           QByteArray *O = va_arg( args, QByteArray * );
00271           struct berval *bv;
00272           ret = ber_scanf( d->mBer, fmt, &bv );
00273           if ( ret != -1 ) {
00274             *O = QByteArray( bv->bv_val, bv->bv_len );
00275             ber_bvfree( bv );
00276           }
00277           break;
00278         }
00279         break;
00280       case 'm': //the same as 'O', just *bv should not be freed.
00281         {
00282           QByteArray *m = va_arg( args, QByteArray * );
00283           struct berval *bv;
00284           ret = ber_scanf( d->mBer, fmt, &bv );
00285           if ( ret != -1 ) {
00286             *m = QByteArray( bv->bv_val, bv->bv_len );
00287           }
00288           break;
00289         }
00290       case 'a':
00291         {
00292           QByteArray *a = va_arg( args, QByteArray * );
00293           char *c;
00294           ret = ber_scanf( d->mBer, fmt, &c );
00295           if ( ret != -1 ) {
00296             *a = QByteArray( c );
00297             ber_memfree( c );
00298           }
00299           break;
00300         }
00301 
00302       case 's':
00303         {
00304           QByteArray *s = va_arg( args, QByteArray * );
00305           char buf[255];
00306           ber_len_t l = sizeof( buf );
00307           ret = ber_scanf( d->mBer, fmt, &buf, &l );
00308           if ( ret != -1 ) {
00309             *s = QByteArray( buf, l );
00310           }
00311           break;
00312         }
00313       case 't':
00314       case 'T':
00315         {
00316           unsigned int *t = va_arg( args, unsigned int * );
00317           ret = ber_scanf( d->mBer, fmt, t );
00318           break;
00319         }
00320         break;
00321       case 'v':
00322         {
00323           QList<QByteArray> *v = va_arg( args, QList<QByteArray> * );
00324           char **c, **c2;
00325           ret = ber_scanf( d->mBer, fmt, &c );
00326           if ( ret != -1 && c ) {
00327             c2 = c;
00328             while ( *c ) {
00329               v->append( QByteArray( *c ) );
00330               ber_memfree( *c );
00331               c++;
00332             }
00333             ber_memfree( (char *) c2 );
00334           }
00335           break;
00336         }
00337       case 'V':
00338         {
00339           QList<QByteArray> *v = va_arg( args, QList<QByteArray> * );
00340           struct berval **bv, **bv2;
00341           ret = ber_scanf( d->mBer, fmt, &bv );
00342           if ( ret != -1 && bv ) {
00343             bv2 = bv;
00344             while ( *bv ) {
00345               v->append( QByteArray( (*bv)->bv_val, (*bv)->bv_len ) );
00346               bv++;
00347             }
00348             ber_bvecfree( bv2 );
00349           }
00350           break;
00351         }
00352       case 'x':
00353       case 'n':
00354       case '{':
00355       case '}':
00356       case '[':
00357       case ']':
00358         ret = ber_scanf( d->mBer, fmt );
00359         break;
00360       default:
00361         kWarning() << "Invalid BER format parameter: '" << fmt << "'";
00362         ret = -1;
00363     }
00364 
00365     kDebug(5322) << "ber_scanf format:" << fmt << "ret:" << ret;
00366     if ( ret == -1 ) {
00367       break;
00368     }
00369 
00370   }
00371   va_end( args );
00372   return ret;
00373 }
00374 
00375 unsigned int Ber::peekTag( int &size )
00376 {
00377   unsigned int ret;
00378   ber_len_t len;
00379   ret = ber_peek_tag( d->mBer, &len );
00380   size = len;
00381   return ret;
00382 }
00383 
00384 unsigned int Ber::skipTag( int &size )
00385 {
00386   unsigned int ret;
00387   ber_len_t len;
00388   ret = ber_skip_tag( d->mBer, &len );
00389   size = len;
00390   return ret;
00391 }
00392 #else
00393 
00394 Ber::Ber()
00395  : d( new BerPrivate )
00396 {
00397   kError() << "LDAP support not compiled";
00398 }
00399 
00400 Ber::Ber( const QByteArray & )
00401  : d( new BerPrivate )
00402 {
00403   kError() << "LDAP support not compiled";
00404 }
00405 
00406 Ber::~Ber()
00407 {
00408   delete d;
00409 }
00410 
00411 Ber::Ber( const Ber&)
00412  : d( new BerPrivate )
00413 {
00414   kError() << "LDAP support not compiled";
00415 }
00416 
00417 Ber &Ber::operator=( const Ber &that )
00418 {
00419   if ( this == &that ) {
00420     return *this;
00421   }
00422   kError() << "LDAP support not compiled";
00423   return *this;
00424 }
00425 
00426 QByteArray Ber::flatten() const
00427 {
00428   kError() << "LDAP support not compiled";
00429   return QByteArray();
00430 }
00431 
00432 int Ber::printf( const QString &format, ... )
00433 {
00434   Q_UNUSED( format );
00435   kError() << "LDAP support not compiled";
00436   return -1;
00437 }
00438 
00439 int Ber::scanf( const QString &format, ... )
00440 {
00441   Q_UNUSED( format );
00442   kError() << "LDAP support not compiled";
00443   return -1;
00444 }
00445 
00446 unsigned int Ber::peekTag( int &size )
00447 {
00448   Q_UNUSED( size );
00449   kError() << "LDAP support not compiled";
00450   return -1;
00451 }
00452 
00453 unsigned int Ber::skipTag( int &size )
00454 {
00455   Q_UNUSED( size );
00456   kError() << "LDAP support not compiled";
00457   return -1;
00458 }
00459 
00460 #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"
  • kabc
  • kblog
  • kcal
  • kimap
  • kioslave
  •   imap4
  •   mbox
  • kldap
  • kmime
  • kpimidentities
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Generated for KDE-PIM Libraries by doxygen 1.5.5
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