WIP on #278

mistotebe · mistotebe · commit 8492b16801a0 · 2020-04-30T12:34:03.000+01:00
Would be nice if result4 returned the operation result as well (but for
that we'd need to expose the result codes too, at the moment all of them
are just exceptions that can't even be converted to ints).
diff --git a/Doc/fake_ldap_module_for_documentation.py b/Doc/fake_ldap_module_for_documentation.py
@@ -28,3 +28,5 @@ def get_option(num):
 
 class LDAPError:
     pass
+
+RAISE_ALL = 2
diff --git a/Doc/reference/ldap.rst b/Doc/reference/ldap.rst
@@ -939,10 +939,10 @@ and wait for and return with the server's result, or with
    This method behaves almost exactly like :py:meth:`result2()`. But it
    returns an extra item in the tuple, the decoded server controls.
 
-.. py:method:: LDAPObject.result4([msgid=RES_ANY [, all=1 [, timeout=None [, add_ctrls=0 [, add_intermediates=0 [, add_extop=0 [, resp_ctrl_classes=None]]]]]]]) -> 6-tuple
+.. py:method:: LDAPObject.result4([msgid=RES_ANY [, all=1 [, timeout=None [, add_ctrls=0 [, add_intermediates=0 [, add_extop=0 [, resp_ctrl_classes=None]]]]]]]) -> 7-tuple
 
    This method behaves almost exactly like :py:meth:`result3()`. But it
-   returns an extra items in the tuple, the decoded results of an extended response.
+   returns extra items in the tuple, the result code and decoded results of an extended response.
 
    The additional arguments are:
 
diff --git a/Lib/ldap/ldapobject.py b/Lib/ldap/ldapobject.py
@@ -30,7 +30,7 @@
 from ldap.extop import ExtendedRequest,ExtendedResponse
 from ldap.compat import reraise
 
-from ldap import LDAPError
+from ldap import LDAPError, RAISE_ALL
 
 PY2 = sys.version_info[0] <= 2
 if PY2:
@@ -96,14 +96,14 @@ class SimpleLDAPObject:
   def __init__(
     self,uri,
     trace_level=0,trace_file=None,trace_stack_limit=5,bytes_mode=None,
-    bytes_strictness=None,
+    bytes_strictness=None,raise_for_result=RAISE_ALL,
   ):
     self._trace_level = trace_level or ldap._trace_level
     self._trace_file = trace_file or ldap._trace_file
     self._trace_stack_limit = trace_stack_limit
     self._uri = uri
     self._ldap_object_lock = self._ldap_lock('opcall')
-    self._l = ldap.functions._ldap_function_call(ldap._ldap_module_lock,_ldap.initialize,uri)
+    self._l = ldap.functions._ldap_function_call(ldap._ldap_module_lock,_ldap.initialize,uri,raise_for_result)
     self.timeout = -1
     self.protocol_version = ldap.VERSION3
 
@@ -520,14 +520,16 @@ def compare_ext(self,dn,attr,value,serverctrls=None,clientctrls=None):
   def compare_ext_s(self,dn,attr,value,serverctrls=None,clientctrls=None):
     msgid = self.compare_ext(dn,attr,value,serverctrls,clientctrls)
     try:
-        ldap_res = self.result3(msgid,all=1,timeout=self.timeout)
+        ldap_res = self.result4(msgid,all=1,timeout=self.timeout)
+        if ldap_res[1] == ldap.COMPARE_TRUE.errnum:
+            return True
+        if ldap_res[1] == ldap.COMPARE_FALSE.errnum:
+            return False
+        return ldap_res
     except ldap.COMPARE_TRUE:
       return True
     except ldap.COMPARE_FALSE:
       return False
-    raise ldap.PROTOCOL_ERROR(
-        'Compare operation returned wrong result: %r' % (ldap_res,)
-    )
 
   def compare(self,dn,attr,value):
     return self.compare_ext(dn,attr,value,None,None)
@@ -576,7 +578,7 @@ def extop(self,extreq,serverctrls=None,clientctrls=None):
     return self._ldap_call(self._l.extop,extreq.requestName,extreq.encodedRequestValue(),RequestControlTuples(serverctrls),RequestControlTuples(clientctrls))
 
   def extop_result(self,msgid=ldap.RES_ANY,all=1,timeout=None):
-    resulttype,msg,msgid,respctrls,respoid,respvalue = self.result4(msgid,all=1,timeout=self.timeout,add_ctrls=1,add_intermediates=1,add_extop=1)
+    msgtype,result,msg,msgid,respctrls,respoid,respvalue = self.result4(msgid,all=1,timeout=self.timeout,add_ctrls=1,add_intermediates=1,add_extop=1)
     return (respoid,respvalue)
 
   def extop_s(self,extreq,serverctrls=None,clientctrls=None,extop_resp_class=None):
@@ -737,39 +739,39 @@ def result(self,msgid=ldap.RES_ANY,all=1,timeout=None):
         If a timeout occurs, a TIMEOUT exception is raised, unless
         polling (timeout = 0), in which case (None, None) is returned.
     """
-    resp_type, resp_data, resp_msgid = self.result2(msgid,all,timeout)
-    return resp_type, resp_data
+    msgtype, resp_data, resp_msgid = self.result2(msgid,all,timeout)
+    return msgtype, resp_data
 
   def result2(self,msgid=ldap.RES_ANY,all=1,timeout=None):
-    resp_type, resp_data, resp_msgid, resp_ctrls = self.result3(msgid,all,timeout)
-    return resp_type, resp_data, resp_msgid
+    msgtype, resp_data, resp_msgid, resp_ctrls = self.result3(msgid,all,timeout)
+    return msgtype, resp_data, resp_msgid
 
   def result3(self,msgid=ldap.RES_ANY,all=1,timeout=None,resp_ctrl_classes=None):
-    resp_type, resp_data, resp_msgid, decoded_resp_ctrls, retoid, retval = self.result4(
+    msgtype, result, resp_data, resp_msgid, decoded_resp_ctrls, retoid, retval = self.result4(
       msgid,all,timeout,
       add_ctrls=0,add_intermediates=0,add_extop=0,
       resp_ctrl_classes=resp_ctrl_classes
     )
-    return resp_type, resp_data, resp_msgid, decoded_resp_ctrls
+    return msgtype, resp_data, resp_msgid, decoded_resp_ctrls
 
   def result4(self,msgid=ldap.RES_ANY,all=1,timeout=None,add_ctrls=0,add_intermediates=0,add_extop=0,resp_ctrl_classes=None):
     if timeout is None:
       timeout = self.timeout
     ldap_result = self._ldap_call(self._l.result4,msgid,all,timeout,add_ctrls,add_intermediates,add_extop)
     if ldap_result is None:
-        resp_type, resp_data, resp_msgid, resp_ctrls, resp_name, resp_value = (None,None,None,None,None,None)
+        resp_type, result, resp_data, resp_msgid, resp_ctrls, resp_name, resp_value = (None,None,None,None,None,None,None)
     else:
-      if len(ldap_result)==4:
-        resp_type, resp_data, resp_msgid, resp_ctrls = ldap_result
+      if len(ldap_result)==5:
+        resp_type, result, resp_data, resp_msgid, resp_ctrls = ldap_result
         resp_name, resp_value = None,None
       else:
-        resp_type, resp_data, resp_msgid, resp_ctrls, resp_name, resp_value = ldap_result
+        resp_type, result, resp_data, resp_msgid, resp_ctrls, resp_name, resp_value = ldap_result
       if add_ctrls:
         resp_data = [ (t,r,DecodeControlTuples(c,resp_ctrl_classes)) for t,r,c in resp_data ]
     decoded_resp_ctrls = DecodeControlTuples(resp_ctrls,resp_ctrl_classes)
     if resp_data is not None:
         resp_data = self._bytesify_results(resp_data, with_ctrls=add_ctrls)
-    return resp_type, resp_data, resp_msgid, decoded_resp_ctrls, resp_name, resp_value
+    return resp_type, result, resp_data, resp_msgid, decoded_resp_ctrls, resp_name, resp_value
 
   def search_ext(self,base,scope,filterstr=None,attrlist=None,attrsonly=0,serverctrls=None,clientctrls=None,timeout=-1,sizelimit=0):
     """
@@ -1086,7 +1088,7 @@ class ReconnectLDAPObject(SimpleLDAPObject):
   def __init__(
     self,uri,
     trace_level=0,trace_file=None,trace_stack_limit=5,bytes_mode=None,
-    bytes_strictness=None, retry_max=1, retry_delay=60.0
+    bytes_strictness=None, raise_for_result=RAISE_ALL, retry_max=1, retry_delay=60.0
   ):
     """
     Parameters like SimpleLDAPObject.__init__() with these
@@ -1102,7 +1104,8 @@ def __init__(
     self._last_bind = None
     SimpleLDAPObject.__init__(self, uri, trace_level, trace_file,
                               trace_stack_limit, bytes_mode,
-                              bytes_strictness=bytes_strictness)
+                              bytes_strictness=bytes_strictness,
+                              raise_for_result=raise_for_result)
     self._reconnect_lock = ldap.LDAPLock(desc='reconnect lock within %s' % (repr(self)))
     self._retry_max = retry_max
     self._retry_delay = retry_delay
diff --git a/Lib/ldap/syncrepl.py b/Lib/ldap/syncrepl.py
@@ -399,15 +399,15 @@ def syncrepl_poll(self, msgid=-1, timeout=None, all=0):
 
         """
         while True:
-            type, msg, mid, ctrls, n, v = self.result4(
+            msgtype, result, msg, mid, ctrls, n, v = self.result4(
                 msgid=msgid,
                 timeout=timeout,
                 add_intermediates=1,
                 add_ctrls=1,
                 all=0,
             )
 
-            if type == 101:
+            if msgtype == 101:
                 # search result. This marks the end of a refreshOnly session.
                 # look for a SyncDone control, save the cookie, and if necessary
                 # delete non-present entries.
@@ -420,7 +420,7 @@ def syncrepl_poll(self, msgid=-1, timeout=None, all=0):
 
                 return False
 
-            elif type == 100:
+            elif msgtype == 100:
                 # search entry with associated SyncState control
                 for m in msg:
                     dn, attrs, ctrls = m
@@ -439,7 +439,7 @@ def syncrepl_poll(self, msgid=-1, timeout=None, all=0):
                             self.syncrepl_set_cookie(c.cookie)
                         break
 
-            elif type == 121:
+            elif msgtype == 121:
                 # Intermediate message. If it is a SyncInfoMessage, parse it
                 for m in msg:
                     rname, resp, ctrls = m
diff --git a/Modules/LDAPObject.c b/Modules/LDAPObject.c
@@ -21,7 +21,7 @@ static void free_attrs(char ***);
 /* constructor */
 
 LDAPObject *
-newLDAPObject(LDAP *l)
+newLDAPObject(LDAP *l, int raise_for_result)
 {
     LDAPObject *self = (LDAPObject *)PyObject_NEW(LDAPObject, &LDAP_Type);
 
@@ -30,6 +30,7 @@ newLDAPObject(LDAP *l)
     self->ldap = l;
     self->_save = NULL;
     self->valid = 1;
+    self->raise_for_result = raise_for_result;
     return self;
 }
 
@@ -1086,6 +1087,7 @@ l_ldap_result4(LDAPObject *self, PyObject *args)
     char *retoid = 0;
     PyObject *valuestr = NULL;
     int result = LDAP_SUCCESS;
+    int should_raise = 0;
     LDAPControl **serverctrls = 0;
 
     if (!PyArg_ParseTuple
@@ -1161,7 +1163,21 @@ l_ldap_result4(LDAPObject *self, PyObject *args)
         LDAP_END_ALLOW_THREADS(self);
     }
 
-    if (result != LDAP_SUCCESS) {       /* result error */
+    switch (result) {
+        case LDAP_SUCCESS:
+            should_raise = 0;
+            break;
+        case LDAP_COMPARE_FALSE:
+        case LDAP_COMPARE_TRUE:
+        case LDAP_REFERRAL:
+        case LDAP_SASL_BIND_IN_PROGRESS:
+            if ( self->raise_for_result <= RAISE_ON_ERROR ) break;
+            /* Fallthrough */
+        default:
+            should_raise = self->raise_for_result > DONT_RAISE;
+            break;
+    }
+    if (should_raise) {
         ldap_controls_free(serverctrls);
         Py_XDECREF(valuestr);
         return LDAPraise_for_message(self->ldap, "ldap_parse_result", msg);
@@ -1189,13 +1205,14 @@ l_ldap_result4(LDAPObject *self, PyObject *args)
     else {
         /* s handles NULL, but O does not */
         if (add_extop) {
-            retval = Py_BuildValue("(iOiOsO)", res_type, pmsg, res_msgid,
-                                   pyctrls, retoid,
+            retval = Py_BuildValue("(iiOiOsO)", res_type, result, pmsg,
+                                   res_msgid, pyctrls, retoid,
                                    valuestr ? valuestr : Py_None);
         }
         else {
             retval =
-                Py_BuildValue("(iOiO)", res_type, pmsg, res_msgid, pyctrls);
+                Py_BuildValue("(iiOiO)", res_type, result, pmsg, res_msgid,
+                              pyctrls);
         }
 
         if (pmsg != Py_None) {
diff --git a/Modules/LDAPObject.h b/Modules/LDAPObject.h
@@ -21,13 +21,14 @@ typedef struct {
     PyObject_HEAD LDAP *ldap;
     _threadstate _save;         /* for thread saving on referrals */
     int valid;
+    int raise_for_result;
 } LDAPObject;
 
 extern PyTypeObject LDAP_Type;
 
 #define LDAPObject_Check(v)     (Py_TYPE(v) == &LDAP_Type)
 
-extern LDAPObject *newLDAPObject(LDAP *);
+extern LDAPObject *newLDAPObject(LDAP *, int);
 
 /* macros to allow thread saving in the context of an LDAP connection */
 
diff --git a/Modules/constants.c b/Modules/constants.c
@@ -205,6 +205,13 @@ LDAPinit_constants(PyObject *m)
     if (PyModule_AddIntConstant(m, "OPT_OFF", 0) != 0)
         return -1;
 
+    if (PyModule_AddIntMacro(m, DONT_RAISE) != 0)
+        return -1;
+    if (PyModule_AddIntMacro(m, RAISE_ON_ERROR) != 0)
+        return -1;
+    if (PyModule_AddIntMacro(m, RAISE_ALL) != 0)
+        return -1;
+
     /* exceptions */
 
     LDAPexception_class = PyErr_NewException("ldap.LDAPError", NULL, NULL);
diff --git a/Modules/constants.h b/Modules/constants.h
@@ -23,4 +23,8 @@ PyObject *LDAPerr(int errnum);
 #define LDAP_CONTROL_VALUESRETURNFILTER "1.2.826.0.1.3344810.2.3"       /* RFC 3876 */
 #endif /* !LDAP_CONTROL_VALUESRETURNFILTER */
 
+#define DONT_RAISE 0
+#define RAISE_ON_ERROR 1
+#define RAISE_ALL 2
+
 #endif /* __h_constants_ */
diff --git a/Modules/functions.c b/Modules/functions.c
@@ -13,11 +13,12 @@ static PyObject *
 l_ldap_initialize(PyObject *unused, PyObject *args)
 {
     char *uri;
+    int raise_for_result = RAISE_ALL;
     LDAP *ld = NULL;
     int ret;
     PyThreadState *save;
 
-    if (!PyArg_ParseTuple(args, "s:initialize", &uri))
+    if (!PyArg_ParseTuple(args, "s|i:initialize", &uri, &raise_for_result))
         return NULL;
 
     save = PyEval_SaveThread();
@@ -27,7 +28,7 @@ l_ldap_initialize(PyObject *unused, PyObject *args)
     if (ret != LDAP_SUCCESS)
         return LDAPerror(ld, "ldap_initialize");
 
-    return (PyObject *)newLDAPObject(ld);
+    return (PyObject *)newLDAPObject(ld, raise_for_result);
 }
 
 /* ldap_str2dn */
diff --git a/Tests/t_cext.py b/Tests/t_cext.py
diff --git a/Tests/t_ldapobject.py b/Tests/t_ldapobject.py
