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 {
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
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
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':
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