git.sur5r.net Git - openldap/blob - libraries/libldap/abandon.c

   1 /*
   2  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  */
   5 /*  Portions
   6  *  Copyright (c) 1990 Regents of the University of Michigan.
   7  *  All rights reserved.
   8  *
   9  *  abandon.c
  10  */
  11
  12 #include "portable.h"
  13
  14 #include <stdio.h>
  15
  16 #include <ac/stdlib.h>
  17
  18 #include <ac/socket.h>
  19 #include <ac/string.h>
  20 #include <ac/time.h>
  21
  22 #include "ldap-int.h"
  23
  24 static int do_abandon LDAP_P((
  25         LDAP *ld,
  26         int origid,
  27         int msgid,
  28         LDAPControl **sctrls,
  29         LDAPControl **cctrls));
  30
  31 /*
  32  * ldap_abandon_ext - perform an ldap extended abandon operation.
  33  *
  34  * Parameters:
  35  *      ld                      LDAP descriptor
  36  *      msgid           The message id of the operation to abandon
  37  *      scntrls         Server Controls
  38  *      ccntrls         Client Controls
  39  *
  40  * ldap_abandon_ext returns a LDAP error code.
  41  *              (LDAP_SUCCESS if everything went ok)
  42  *
  43  * Example:
  44  *      ldap_abandon_ext( ld, msgid, scntrls, ccntrls );
  45  */
  46 int
  47 ldap_abandon_ext(
  48         LDAP *ld,
  49         int msgid,
  50         LDAPControl **sctrls,
  51         LDAPControl **cctrls )
  52 {
  53         Debug( LDAP_DEBUG_TRACE, "ldap_abandon_ext %d\n", msgid, 0, 0 );
  54
  55         return do_abandon( ld, msgid, msgid, sctrls, cctrls );
  56 }
  57
  58
  59 /*
  60  * ldap_abandon - perform an ldap abandon operation. Parameters:
  61  *
  62  *      ld              LDAP descriptor
  63  *      msgid           The message id of the operation to abandon
  64  *
  65  * ldap_abandon returns 0 if everything went ok, -1 otherwise.
  66  *
  67  * Example:
  68  *      ldap_abandon( ld, msgid );
  69  */
  70 int
  71 ldap_abandon( LDAP *ld, int msgid )
  72 {
  73         Debug( LDAP_DEBUG_TRACE, "ldap_abandon %d\n", msgid, 0, 0 );
  74         return do_abandon( ld, msgid, msgid, NULL, NULL ) == LDAP_SUCCESS
  75                 ? 0 : -1;
  76 }
  77
  78
  79 static int
  80 do_abandon(
  81         LDAP *ld,
  82         int origid,
  83         int msgid,
  84         LDAPControl **sctrls,
  85         LDAPControl **cctrls)
  86 {
  87         BerElement      *ber;
  88         int             i, err, sendabandon;
  89         unsigned int *old_abandon;
  90         Sockbuf         *sb;
  91         LDAPRequest     *lr;
  92
  93         /*
  94          * An abandon request looks like this:
  95          *      AbandonRequest ::= MessageID
  96          */
  97
  98         Debug( LDAP_DEBUG_TRACE, "do_abandon origid %d, msgid %d\n",
  99                 origid, msgid, 0 );
 100
 101         sendabandon = 1;
 102
 103         /* find the request that we are abandoning */
 104         for ( lr = ld->ld_requests; lr != NULL; lr = lr->lr_next ) {
 105                 if ( lr->lr_msgid == msgid ) {  /* this message */
 106                         break;
 107                 }
 108                 if ( lr->lr_origid == msgid ) {/* child:  abandon it */
 109                         (void) do_abandon( ld,
 110                                 msgid, lr->lr_msgid, sctrls, cctrls );
 111                 }
 112         }
 113
 114         if ( lr != NULL ) {
 115                 if ( origid == msgid && lr->lr_parent != NULL ) {
 116                         /* don't let caller abandon child requests! */
 117                         ld->ld_errno = LDAP_PARAM_ERROR;
 118                         return( LDAP_PARAM_ERROR );
 119                 }
 120                 if ( lr->lr_status != LDAP_REQST_INPROGRESS ) {
 121                         /* no need to send abandon message */
 122                         sendabandon = 0;
 123                 }
 124         }
 125
 126         if ( ldap_msgdelete( ld, msgid ) == 0 ) {
 127                 ld->ld_errno = LDAP_SUCCESS;
 128                 return LDAP_SUCCESS;
 129         }
 130
 131         err = 0;
 132         if ( sendabandon ) {
 133                 /* create a message to send */
 134                 if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) {
 135                         err = -1;
 136                         ld->ld_errno = LDAP_NO_MEMORY;
 137
 138                 } else {
 139 #ifdef LDAP_CONNECTIONLESS
 140                         if ( ld->ld_cldapnaddr > 0 ) {
 141                                 err = ber_printf( ber, "{isti", /* leave open '}' */
 142                                     ++ld->ld_msgid, ld->ld_cldapdn,
 143                                     LDAP_REQ_ABANDON, msgid );
 144                         } else
 145 #endif /* LDAP_CONNECTIONLESS */
 146                         {
 147                                 err = ber_printf( ber, "{iti",  /* leave open '}' */
 148                                         ++ld->ld_msgid,
 149                                     LDAP_REQ_ABANDON, msgid );
 150                         }
 151
 152                         if( err == -1 ) {
 153                                 /* encoding error */
 154                                 ld->ld_errno = LDAP_ENCODING_ERROR;
 155
 156                         } else {
 157                                 /* Put Server Controls */
 158                                 if ( ldap_int_put_controls( ld, sctrls, ber )
 159                                         != LDAP_SUCCESS )
 160                                 {
 161                                         err = -1;
 162
 163                                 } else {
 164                                         /* close '{' */
 165                                         err = ber_printf( ber, "}" );
 166
 167                                         if( err == -1 ) {
 168                                                 /* encoding error */
 169                                                 ld->ld_errno = LDAP_ENCODING_ERROR;
 170                                         }
 171                                 }
 172                         }
 173
 174                         if ( err == -1 ) {
 175                                 ber_free( ber, 1 );
 176
 177                         } else {
 178                                 /* send the message */
 179                                 if ( lr != NULL ) {
 180                                         sb = lr->lr_conn->lconn_sb;
 181                                 } else {
 182                                         sb = &ld->ld_sb;
 183                                 }
 184
 185                                 if ( ber_flush( sb, ber, 1 ) != 0 ) {
 186                                         ld->ld_errno = LDAP_SERVER_DOWN;
 187                                         err = -1;
 188                                 } else {
 189                                         err = 0;
 190                                 }
 191                         }
 192                 }
 193         }
 194
 195         if ( lr != NULL ) {
 196                 if ( sendabandon ) {
 197                         ldap_free_connection( ld, lr->lr_conn, 0, 1 );
 198                 }
 199                 if ( origid == msgid ) {
 200                         ldap_free_request( ld, lr );
 201                 }
 202         }
 203
 204         i = 0;
 205         if ( ld->ld_abandoned != NULL ) {
 206                 for ( ; ld->ld_abandoned[i] != -1; i++ )
 207                         ;       /* NULL */
 208         }
 209
 210         old_abandon = ld->ld_abandoned;
 211
 212         ld->ld_abandoned = (int *) LDAP_REALLOC( (char *)
 213                 ld->ld_abandoned, (i + 2) * sizeof(int) );
 214
 215         if ( ld->ld_abandoned == NULL ) {
 216                 ld->ld_abandoned = old_abandon;
 217                 ld->ld_errno = LDAP_NO_MEMORY;
 218                 return( ld->ld_errno );
 219         }
 220
 221         ld->ld_abandoned[i] = msgid;
 222         ld->ld_abandoned[i + 1] = -1;
 223
 224         if ( err != -1 ) {
 225                 ld->ld_errno = LDAP_SUCCESS;
 226         }
 227
 228         return( ld->ld_errno );
 229 }