00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
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
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
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':
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