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 /*
  13  * An abandon request looks like this:
  14  *      AbandonRequest ::= MessageID
  15  */
  16
  17 #include "portable.h"
  18
  19 #include <stdio.h>
  20
  21 #include <ac/stdlib.h>
  22
  23 #include <ac/socket.h>
  24 #include <ac/string.h>
  25 #include <ac/time.h>
  26
  27 #include "ldap-int.h"
  28
  29 static int do_abandon LDAP_P((
  30         LDAP *ld,
  31         int origid,
  32         int msgid,
  33         LDAPControl **sctrls,
  34         LDAPControl **cctrls));
  35
  36 /*
  37  * ldap_abandon_ext - perform an ldap extended abandon operation.
  38  *
  39  * Parameters:
  40  *      ld                      LDAP descriptor
  41  *      msgid           The message id of the operation to abandon
  42  *      scntrls         Server Controls
  43  *      ccntrls         Client Controls
  44  *
  45  * ldap_abandon_ext returns a LDAP error code.
  46  *              (LDAP_SUCCESS if everything went ok)
  47  *
  48  * Example:
  49  *      ldap_abandon_ext( ld, msgid, scntrls, ccntrls );
  50  */
  51 int
  52 ldap_abandon_ext(
  53         LDAP *ld,
  54         int msgid,
  55         LDAPControl **sctrls,
  56         LDAPControl **cctrls )
  57 {
  58         Debug( LDAP_DEBUG_TRACE, "ldap_abandon_ext %d\n", msgid, 0, 0 );
  59
  60         return do_abandon( ld, msgid, msgid, sctrls, cctrls );
  61 }
  62
  63
  64 /*
  65  * ldap_abandon - perform an ldap abandon operation. Parameters:
  66  *
  67  *      ld              LDAP descriptor
  68  *      msgid           The message id of the operation to abandon
  69  *
  70  * ldap_abandon returns 0 if everything went ok, -1 otherwise.
  71  *
  72  * Example:
  73  *      ldap_abandon( ld, msgid );
  74  */
  75 int
  76 ldap_abandon( LDAP *ld, int msgid )
  77 {
  78         Debug( LDAP_DEBUG_TRACE, "ldap_abandon %d\n", msgid, 0, 0 );
  79         return do_abandon( ld, msgid, msgid, NULL, NULL ) == LDAP_SUCCESS
  80                 ? 0 : -1;
  81 }
  82
  83
  84 static int
  85 do_abandon(
  86         LDAP *ld,
  87         int origid,
  88         int msgid,
  89         LDAPControl **sctrls,
  90         LDAPControl **cctrls)
  91 {
  92         BerElement      *ber;
  93         int             i, err, sendabandon;
  94         unsigned int *old_abandon;
  95         Sockbuf         *sb;
  96         LDAPRequest     *lr;
  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 }