int
ldap_open_internal_connection( LDAP **ldp, ber_socket_t *fdp )
{
int rc;
LDAPConn *c;
LDAPRequest *lr;
LDAP *ld;
rc = ldap_create( &ld );
if( rc != LDAP_SUCCESS ) {
*ldp = NULL;
return( rc );
}
/* Make it appear that a search request, msgid 0, was sent */
lr = (LDAPRequest *)LDAP_CALLOC( 1, sizeof( LDAPRequest ));
if( lr == NULL ) {
ldap_unbind_ext( ld, NULL, NULL );
*ldp = NULL;
return( LDAP_NO_MEMORY );
}
memset(lr, 0, sizeof( LDAPRequest ));
lr->lr_msgid = 0;
lr->lr_status = LDAP_REQST_INPROGRESS;
lr->lr_res_errno = LDAP_SUCCESS;
/* no mutex lock needed, we just created this ld here */
ld->ld_requests = lr;
LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
/* Attach the passed socket as the *LDAP's connection */
c = ldap_new_connection( ld, NULL, 1, 0, NULL, 0, 0 );
if( c == NULL ) {
ldap_unbind_ext( ld, NULL, NULL );
*ldp = NULL;
LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
return( LDAP_NO_MEMORY );
}
ber_sockbuf_ctrl( c->lconn_sb, LBER_SB_OPT_SET_FD, fdp );
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( c->lconn_sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_PROVIDER, (void *)"int_" );
#endif
ber_sockbuf_add_io( c->lconn_sb, &ber_sockbuf_io_tcp,
LBER_SBIOD_LEVEL_PROVIDER, NULL );
ld->ld_defconn = c;
LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
/* Add the connection to the *LDAP's select pool */
ldap_mark_select_read( ld, c->lconn_sb );
ldap_mark_select_write( ld, c->lconn_sb );
/* Make this connection an LDAP V3 protocol connection */
rc = LDAP_VERSION3;
ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION, &rc );
*ldp = ld;
++ld->ld_defconn->lconn_refcnt; /* so it never gets closed/freed */
return( LDAP_SUCCESS );
}
/*
* Call this to do a TLS accept on a sockbuf.
* Everything else is the same as with tls_connect.
*/
int
ldap_pvt_tls_accept( Sockbuf *sb, void *ctx_arg )
{
int err;
tls_session *ssl = NULL;
if ( HAS_TLS( sb )) {
ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
} else {
ssl = alloc_handle( ctx_arg, 1 );
if ( ssl == NULL ) return -1;
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
#endif
ber_sockbuf_add_io( sb, tls_imp->ti_sbio,
LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
}
err = tls_imp->ti_session_accept( ssl );
#ifdef HAVE_WINSOCK
errno = WSAGetLastError();
#endif
if ( err < 0 )
{
if ( update_flags( sb, ssl, err )) return 1;
if ( DebugTest( LDAP_DEBUG_ANY ) ) {
char buf[256], *msg;
msg = tls_imp->ti_session_errmsg( ssl, err, buf, sizeof(buf) );
Debug( LDAP_DEBUG_ANY,"TLS: can't accept: %s.\n",
msg ? msg : "(unknown)", 0, 0 );
}
ber_sockbuf_remove_io( sb, tls_imp->ti_sbio,
LBER_SBIOD_LEVEL_TRANSPORT );
#ifdef LDAP_DEBUG
ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_TRANSPORT );
#endif
return -1;
}
return 0;
}
int ldap_pvt_sasl_generic_install(
Sockbuf *sb,
struct sb_sasl_generic_install *install_arg )
{
Debug0( LDAP_DEBUG_TRACE, "ldap_pvt_sasl_generic_install\n" );
/* don't install the stuff unless security has been negotiated */
if ( !ber_sockbuf_ctrl( sb, LBER_SB_OPT_HAS_IO,
&ldap_pvt_sockbuf_io_sasl_generic ) )
{
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_APPLICATION, (void *)"sasl_generic_" );
#endif
ber_sockbuf_add_io( sb, &ldap_pvt_sockbuf_io_sasl_generic,
LBER_SBIOD_LEVEL_APPLICATION, install_arg );
}
return LDAP_SUCCESS;
}
int
ldap_int_open_connection(
LDAP *ld,
LDAPConn *conn,
LDAPURLDesc *srv,
int async )
{
int rc = -1;
char *host;
int port, proto;
Debug( LDAP_DEBUG_TRACE, "ldap_int_open_connection\n", 0, 0, 0 );
switch ( proto = ldap_pvt_url_scheme2proto( srv->lud_scheme ) ) {
case LDAP_PROTO_TCP:
port = srv->lud_port;
if ( srv->lud_host == NULL || *srv->lud_host == 0 ) {
host = NULL;
} else {
host = srv->lud_host;
}
if( !port ) {
if( strcmp(srv->lud_scheme, "ldaps") == 0 ) {
port = LDAPS_PORT;
} else {
port = LDAP_PORT;
}
}
rc = ldap_connect_to_host( ld, conn->lconn_sb,
proto, host, port, async );
if ( rc == -1 ) return rc;
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_PROVIDER, (void *)"tcp_" );
#endif
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_tcp,
LBER_SBIOD_LEVEL_PROVIDER, NULL );
break;
#ifdef LDAP_CONNECTIONLESS
case LDAP_PROTO_UDP:
port = srv->lud_port;
if ( srv->lud_host == NULL || *srv->lud_host == 0 ) {
host = NULL;
} else {
host = srv->lud_host;
}
if( !port ) port = LDAP_PORT;
LDAP_IS_UDP(ld) = 1;
rc = ldap_connect_to_host( ld, conn->lconn_sb,
proto, host, port, async );
if ( rc == -1 ) return rc;
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_PROVIDER, (void *)"udp_" );
#endif
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_udp,
LBER_SBIOD_LEVEL_PROVIDER, NULL );
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_readahead,
LBER_SBIOD_LEVEL_PROVIDER, NULL );
break;
#endif
case LDAP_PROTO_IPC:
#ifdef LDAP_PF_LOCAL
/* only IPC mechanism supported is PF_LOCAL (PF_UNIX) */
rc = ldap_connect_to_path( ld, conn->lconn_sb,
srv->lud_host, async );
if ( rc == -1 ) return rc;
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_PROVIDER, (void *)"ipc_" );
#endif
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_fd,
LBER_SBIOD_LEVEL_PROVIDER, NULL );
break;
#endif /* LDAP_PF_LOCAL */
default:
return -1;
break;
}
conn->lconn_created = time( NULL );
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_debug,
INT_MAX, (void *)"ldap_" );
#endif
#ifdef LDAP_CONNECTIONLESS
if( proto == LDAP_PROTO_UDP ) return 0;
#endif
#ifdef HAVE_TLS
if (ld->ld_options.ldo_tls_mode == LDAP_OPT_X_TLS_HARD ||
strcmp( srv->lud_scheme, "ldaps" ) == 0 )
{
++conn->lconn_refcnt; /* avoid premature free */
rc = ldap_int_tls_start( ld, conn, srv );
--conn->lconn_refcnt;
if (rc != LDAP_SUCCESS) {
return -1;
}
}
#endif
return( 0 );
}
int
ldap_init_fd(
ber_socket_t fd,
int proto,
LDAP_CONST char *url,
LDAP **ldp
)
{
int rc;
LDAP *ld;
LDAPConn *conn;
*ldp = NULL;
rc = ldap_create( &ld );
if( rc != LDAP_SUCCESS )
return( rc );
if (url != NULL) {
rc = ldap_set_option(ld, LDAP_OPT_URI, url);
if ( rc != LDAP_SUCCESS ) {
ldap_ld_free(ld, 1, NULL, NULL);
return rc;
}
}
/* Attach the passed socket as the LDAP's connection */
conn = ldap_new_connection( ld, NULL, 1, 0, NULL);
if( conn == NULL ) {
ldap_unbind_ext( ld, NULL, NULL );
return( LDAP_NO_MEMORY );
}
ber_sockbuf_ctrl( conn->lconn_sb, LBER_SB_OPT_SET_FD, &fd );
ld->ld_defconn = conn;
++ld->ld_defconn->lconn_refcnt; /* so it never gets closed/freed */
switch( proto ) {
case LDAP_PROTO_TCP:
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_PROVIDER, (void *)"tcp_" );
#endif
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_tcp,
LBER_SBIOD_LEVEL_PROVIDER, NULL );
break;
#ifdef LDAP_CONNECTIONLESS
case LDAP_PROTO_UDP:
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_PROVIDER, (void *)"udp_" );
#endif
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_udp,
LBER_SBIOD_LEVEL_PROVIDER, NULL );
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_readahead,
LBER_SBIOD_LEVEL_PROVIDER, NULL );
break;
#endif /* LDAP_CONNECTIONLESS */
case LDAP_PROTO_IPC:
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_PROVIDER, (void *)"ipc_" );
#endif
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_fd,
LBER_SBIOD_LEVEL_PROVIDER, NULL );
break;
case LDAP_PROTO_EXT:
/* caller must supply sockbuf handlers */
break;
default:
ldap_unbind_ext( ld, NULL, NULL );
return LDAP_PARAM_ERROR;
}
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( conn->lconn_sb, &ber_sockbuf_io_debug,
INT_MAX, (void *)"ldap_" );
#endif
/* Add the connection to the *LDAP's select pool */
ldap_mark_select_read( ld, conn->lconn_sb );
ldap_mark_select_write( ld, conn->lconn_sb );
*ldp = ld;
return LDAP_SUCCESS;
}
static CURLcode ldap_connecting(struct connectdata *conn, bool *done)
{
ldapconninfo *li = conn->proto.generic;
struct SessionHandle *data = conn->data;
LDAPMessage *msg = NULL;
struct timeval tv = {0, 1}, *tvp;
int rc, err;
char *info = NULL;
#ifdef USE_SSL
if(conn->handler->flags & PROTOPT_SSL) {
/* Is the SSL handshake complete yet? */
if(!li->ssldone) {
CURLcode result = Curl_ssl_connect_nonblocking(conn, FIRSTSOCKET,
&li->ssldone);
if(result || !li->ssldone)
return result;
}
/* Have we installed the libcurl SSL handlers into the sockbuf yet? */
if(!li->sslinst) {
Sockbuf *sb;
ldap_get_option(li->ld, LDAP_OPT_SOCKBUF, &sb);
ber_sockbuf_add_io(sb, &ldapsb_tls, LBER_SBIOD_LEVEL_TRANSPORT, conn);
li->sslinst = TRUE;
li->recv = conn->recv[FIRSTSOCKET];
li->send = conn->send[FIRSTSOCKET];
}
}
#endif
tvp = &tv;
retry:
if(!li->didbind) {
char *binddn;
struct berval passwd;
if(conn->bits.user_passwd) {
binddn = conn->user;
passwd.bv_val = conn->passwd;
passwd.bv_len = strlen(passwd.bv_val);
}
else {
binddn = NULL;
passwd.bv_val = NULL;
passwd.bv_len = 0;
}
rc = ldap_sasl_bind(li->ld, binddn, LDAP_SASL_SIMPLE, &passwd,
NULL, NULL, &li->msgid);
if(rc)
return CURLE_LDAP_CANNOT_BIND;
li->didbind = TRUE;
if(tvp)
return CURLE_OK;
}
rc = ldap_result(li->ld, li->msgid, LDAP_MSG_ONE, tvp, &msg);
if(rc < 0) {
failf(data, "LDAP local: bind ldap_result %s", ldap_err2string(rc));
return CURLE_LDAP_CANNOT_BIND;
}
if(rc == 0) {
/* timed out */
return CURLE_OK;
}
rc = ldap_parse_result(li->ld, msg, &err, NULL, &info, NULL, NULL, 1);
if(rc) {
failf(data, "LDAP local: bind ldap_parse_result %s", ldap_err2string(rc));
return CURLE_LDAP_CANNOT_BIND;
}
/* Try to fallback to LDAPv2? */
if(err == LDAP_PROTOCOL_ERROR) {
int proto;
ldap_get_option(li->ld, LDAP_OPT_PROTOCOL_VERSION, &proto);
if(proto == LDAP_VERSION3) {
if(info) {
ldap_memfree(info);
info = NULL;
}
proto = LDAP_VERSION2;
ldap_set_option(li->ld, LDAP_OPT_PROTOCOL_VERSION, &proto);
li->didbind = FALSE;
goto retry;
}
}
if(err) {
failf(data, "LDAP remote: bind failed %s %s", ldap_err2string(rc),
info ? info : "");
if(info)
ldap_memfree(info);
return CURLE_LOGIN_DENIED;
}
if(info)
ldap_memfree(info);
conn->recv[FIRSTSOCKET] = ldap_recv;
*done = TRUE;
return CURLE_OK;
}
static int
ldap_int_tls_connect( LDAP *ld, LDAPConn *conn )
{
Sockbuf *sb = conn->lconn_sb;
int err;
tls_session *ssl = NULL;
if ( HAS_TLS( sb )) {
ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
} else {
struct ldapoptions *lo;
tls_ctx *ctx;
ctx = ld->ld_options.ldo_tls_ctx;
ssl = alloc_handle( ctx, 0 );
if ( ssl == NULL ) return -1;
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
#endif
ber_sockbuf_add_io( sb, tls_imp->ti_sbio,
LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
lo = LDAP_INT_GLOBAL_OPT();
if( ctx == NULL ) {
ctx = lo->ldo_tls_ctx;
ld->ld_options.ldo_tls_ctx = ctx;
tls_ctx_ref( ctx );
}
if ( ld->ld_options.ldo_tls_connect_cb )
ld->ld_options.ldo_tls_connect_cb( ld, ssl, ctx,
ld->ld_options.ldo_tls_connect_arg );
if ( lo && lo->ldo_tls_connect_cb && lo->ldo_tls_connect_cb !=
ld->ld_options.ldo_tls_connect_cb )
lo->ldo_tls_connect_cb( ld, ssl, ctx, lo->ldo_tls_connect_arg );
}
err = tls_imp->ti_session_connect( ld, ssl );
#ifdef HAVE_WINSOCK
errno = WSAGetLastError();
#endif
if ( err < 0 )
{
char buf[256], *msg;
if ( update_flags( sb, ssl, err )) {
return 1;
}
msg = tls_imp->ti_session_errmsg( ssl, err, buf, sizeof(buf) );
if ( msg ) {
if ( ld->ld_error ) {
LDAP_FREE( ld->ld_error );
}
ld->ld_error = LDAP_STRDUP( msg );
#ifdef HAVE_EBCDIC
if ( ld->ld_error ) __etoa(ld->ld_error);
#endif
}
Debug( LDAP_DEBUG_ANY,"TLS: can't connect: %s.\n",
ld->ld_error ? ld->ld_error : "" ,0,0);
ber_sockbuf_remove_io( sb, tls_imp->ti_sbio,
LBER_SBIOD_LEVEL_TRANSPORT );
#ifdef LDAP_DEBUG
ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_TRANSPORT );
#endif
return -1;
}
return 0;
}
int newthread_start(PeerClient *client_info)
{
ber_tag_t tag;
ber_int_t msgid;
ber_int_t msgid_before;
ber_len_t len;
BerElement *ber;
Sockbuf *sb;
ber_len_t max = 409600;
ber_tag_t LdapOpt;
int rc;
TcpHeadInfo socketTcpHead;
int client_conn = client_info->client_conn;
int loop=0;
PrintCap capInfor;
capInfor.peer = *client_info;
#ifdef DEBUG
/* enable debugging */
int ival = -1;
ber_set_option( NULL, LBER_OPT_DEBUG_LEVEL, &ival );
#endif
sb = ber_sockbuf_alloc();
ber_sockbuf_ctrl( sb, LBER_SB_OPT_SET_MAX_INCOMING, &max );
while(1){
loop ++;
//printf(">>>>>>>>>>>>>>>>>While Loop the %d Packet<<<<<<<<<<<<<<<<<<<<<<\n", loop);
/*---------------------------------------------------------------------
Recieve the data from Socket, Function of "recv" is a standard func of
getting data from socket, the purpose of "recv" is getting the TCP head
related infor that sent from client, and put into a struct.
This struct must be exactly aligned with client side,otherwis the data
may not readable
----------------------------------------------------------------------*/
//printf("\n\nDebug:-------Recv Data of TCP head\n");
rc = recv(client_conn, (char *)&socketTcpHead, sizeof(socketTcpHead),0);
if(rc < 0){
printf("TCP Head Recv failed!\n");
exit (0);
}
capInfor.PackageHead = socketTcpHead;
#ifdef DEBUGA
printf("TCP Head info len: %d\n", rc);
printf("Time tag: %u:%u\n", PCAP.TimeStmap.tv_sec,PCAP.TimeStmap.tv_usec );
printf("Pkt number: %d\n", capInfor.PackageHead.GetPackageNumber);
printf("IP layer len: %d\n", capInfor.PackageHead.size_ip);
printf("TCP layer len: %d\n", capInfor.PackageHead.size_tcp);
printf("Protocol: %d\n", capInfor.PackageHead.Prctl);
printf("Src IP: %s\n", capInfor.PackageHead.ipSrc);
printf("Dst IP: %s\n", capInfor.PackageHead.ipDst);
printf("Payload len %d\n", capInfor.PackageHead.Payload_size);
#endif
/*----------------------------------------------------------------------
"ber_sockbuf_add_io" is a function that supplied by "liblber" , it can
get the socket information like "recv", that means here no need to call
recv agian.
Why here use the "ber_sockbuf_add_io" instead of recv?
this time the payload, actually there is ldap protocol data streams are
sent by client, and LDAP protocol use BER(ASN.1) encode method,if use
this function, handy for decode the ldap information.
Like recv, it also is stuck before any data coming.
sb : socket buff, storing the data gather from socket.
-------------------------------------------------------------------------*/
//printf("Debug:-------Recv Data of Payload infor\n");
ber_sockbuf_add_io( sb, &ber_sockbuf_io_tcp, LBER_SBIOD_LEVEL_PROVIDER, (void *)&client_conn );
//printf("Debug:-------Decode BER starting\n");
//Create and allocate memory for BER struct, BER struct can store the infor which was parsed by above function
ber = ber_alloc_t(LBER_USE_DER);
if( ber == NULL ) {
perror( "ber_alloc_t" );
return( EXIT_FAILURE );
}
/*----------------------------------------------------------------------
"ber_get_next", it links the socket buff and BER struct. now all ldap data
has been transfer to the struct of ber. lib of lber and ldap can use it for
ldap layer decoding.
-------------------------------------------------------------------------*/
for (;;) {
tag = ber_get_next( sb, &len, ber);
if( tag != LBER_ERROR ) break;
if( errno == EWOULDBLOCK ) continue;
if( errno == EAGAIN ) continue;
//perror( "ber_get_next" );
return( EXIT_FAILURE );
}
//determine the Ldap option kind
LdapOpt=checkLDAPoption(ber, &msgid);
if(LdapOpt==LBER_ERROR){
printf("|-Error:LDAP option decode failed.\n");
}
/* -1 Sem: Sync the displaying in STDOUT. Only 1 thread is able to
throw the information to screen in same time, othre thread is waiting
for the bin_sem become a non-zero(1) value to take the charge in output
*/
//printf("Debug:------Sem Wait!\n");
/*-----------------Sync-Area--BEGIN---Semaphore-Control-------------------------------*/
/*---Below function displays decoded information of PDU to screen inside each thread--*/
/*---Screen resource would be used by different threads, in order to make a complete--*/
/*---LDAP packet output,I use semaphore to sync each thread. the below command lines--*/
/*---realize a packet decode and display.---------------------------------------------*/
/*-*/ sem_wait(&bin_sem);
/*-*/ //printf("Debug:------Sem OK go ahead!\n");
/*-*/ msgid_before = msgid;
/*-*/
/*-*/ //printf("Debug:------Format output infor\n");
/*-*/ FormatPrintLdap(LdapOpt, msgid, ber, capInfor);
/*-*/
/*-*/ /* +1 Sem: After this time the LDAP PDU Decoding&Outputing completed,
/*-*/ // plus 1 to set the bin_sem, then other thread will be able to use the
/*-*/ // STDOUT.
/*-*/
/*-*/ sem_post(&bin_sem);// +1 Sem
/*-----------------Sync-Area---END----Semaphore-Control--------------------------------*/
}
//close(client_conn);
}
static
int
NewConnection(
ber_socket_t sfd,
VDIR_CONNECTION **ppConnection,
Sockbuf_IO *pSockbuf_IO
)
{
int retVal = LDAP_SUCCESS;
ber_len_t max = SOCK_BUF_MAX_INCOMING;
PVDIR_CONNECTION pConn;
PSTR pszLocalErrMsg = NULL;
if (VmDirAllocateMemory(sizeof(VDIR_CONNECTION), (PVOID *)&pConn) != 0)
{
retVal = LDAP_OPERATIONS_ERROR;
BAIL_ON_VMDIR_ERROR_WITH_MSG(retVal, pszLocalErrMsg, "NewConnection: VmDirAllocateMemory call failed");
}
pConn->bIsAnonymousBind = TRUE; // default to anonymous bind
pConn->sd = sfd;
retVal = VmDirGetNetworkInfoFromSocket(pConn->sd, pConn->szClientIP, sizeof(pConn->szClientIP), &pConn->dwClientPort, true);
BAIL_ON_VMDIR_ERROR(retVal);
retVal = VmDirGetNetworkInfoFromSocket(pConn->sd, pConn->szServerIP, sizeof(pConn->szServerIP), &pConn->dwServerPort, false);
BAIL_ON_VMDIR_ERROR(retVal);
VMDIR_LOG_DEBUG(VMDIR_LOG_MASK_ALL, "New connection (%s)", pConn->szClientIP);
if ((pConn->sb = ber_sockbuf_alloc()) == NULL)
{
retVal = LDAP_OPERATIONS_ERROR;
BAIL_ON_VMDIR_ERROR_WITH_MSG(retVal, pszLocalErrMsg, "New Connection (%s): ber_sockbuf_alloc() call failed with errno: %d", pConn->szClientIP, errno);
}
if (ber_sockbuf_ctrl(pConn->sb, LBER_SB_OPT_SET_MAX_INCOMING, &max) < 0)
{
retVal = LDAP_OPERATIONS_ERROR;
BAIL_ON_VMDIR_ERROR_WITH_MSG(retVal, pszLocalErrMsg, "NewConnection (%s): ber_sockbuf_ctrl() failed while setting MAX_INCOMING", pConn->szClientIP);
}
if (ber_sockbuf_add_io(pConn->sb, pSockbuf_IO, LBER_SBIOD_LEVEL_PROVIDER, (void *)&sfd) != 0)
{
retVal = LDAP_OPERATIONS_ERROR;
BAIL_ON_VMDIR_ERROR_WITH_MSG(retVal, pszLocalErrMsg, "NewConnection (%s): ber_sockbuf_addd_io() failed while setting LEVEL_PROVIDER", pConn->szClientIP);
}
//This is to disable NONBLOCK mode (when NULL passed in)
if (ber_sockbuf_ctrl(pConn->sb, LBER_SB_OPT_SET_NONBLOCK, NULL) < 0)
{
retVal = LDAP_OPERATIONS_ERROR;
BAIL_ON_VMDIR_ERROR_WITH_MSG(retVal, pszLocalErrMsg, "NewConnection (%s): ber_sockbuf_ctrl failed while setting NONBLOCK", pConn->szClientIP);
}
*ppConnection = pConn;
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszLocalErrMsg);
return retVal;
error:
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "NewConnection failing with error %d", retVal);
goto cleanup;
}
int
main( int argc, char **argv )
{
char *s;
int fd, rc;
BerElement *ber;
Sockbuf *sb;
/* enable debugging */
int ival = -1;
ber_set_option( NULL, LBER_OPT_DEBUG_LEVEL, &ival );
if ( argc < 2 ) {
usage( argv[0] );
return( EXIT_FAILURE );
}
#ifdef HAVE_CONSOLE_H
ccommand( &argv );
cshow( stdout );
if (( fd = open( "lber-test", O_WRONLY|O_CREAT|O_TRUNC|O_BINARY ))
< 0 ) {
perror( "open" );
return( EXIT_FAILURE );
}
#else
fd = fileno(stdout);
#endif
sb = ber_sockbuf_alloc();
ber_sockbuf_add_io( sb, &ber_sockbuf_io_fd, LBER_SBIOD_LEVEL_PROVIDER,
(void *)&fd );
if( sb == NULL ) {
perror( "ber_sockbuf_alloc_fd" );
return( EXIT_FAILURE );
}
if ( (ber = ber_alloc_t( LBER_USE_DER )) == NULL ) {
perror( "ber_alloc" );
return( EXIT_FAILURE );
}
fprintf(stderr, "encode: start\n" );
if( ber_printf( ber, "{" /*}*/ ) ) {
perror( "ber_printf {" /*}*/ );
return( EXIT_FAILURE );
}
for ( s = argv[1]; *s; s++ ) {
char *buf;
char fmt[2];
fmt[0] = *s;
fmt[1] = '\0';
fprintf(stderr, "encode: %s\n", fmt );
switch ( *s ) {
case 'i': /* int */
case 'b': /* boolean */
case 'e': /* enumeration */
buf = getbuf();
rc = ber_printf( ber, fmt, atoi(buf) );
break;
case 'n': /* null */
case '{': /* begin sequence */
case '}': /* end sequence */
case '[': /* begin set */
case ']': /* end set */
rc = ber_printf( ber, fmt );
break;
case 'o': /* octet string (non-null terminated) */
case 'B': /* bit string */
buf = getbuf();
rc = ber_printf( ber, fmt, buf, strlen(buf) );
break;
case 's': /* string */
case 't': /* tag for the next element */
buf = getbuf();
rc = ber_printf( ber, fmt, buf );
break;
default:
fprintf( stderr, "encode: unknown fmt %c\n", *fmt );
rc = -1;
break;
}
if( rc == -1 ) {
perror( "ber_printf" );
return( EXIT_FAILURE );
}
}
fprintf(stderr, "encode: end\n" );
if( ber_printf( ber, /*{*/ "N}" ) == -1 ) {
perror( /*{*/ "ber_printf }" );
return( EXIT_FAILURE );
}
if ( ber_flush( sb, ber, 1 ) == -1 ) {
perror( "ber_flush" );
return( EXIT_FAILURE );
}
ber_sockbuf_free( sb );
return( EXIT_SUCCESS );
}
int
main( int argc, char **argv )
{
char *s;
ber_tag_t tag;
ber_len_t len;
BerElement *ber;
Sockbuf *sb;
int fd;
/* enable debugging */
int ival = -1;
ber_set_option( NULL, LBER_OPT_DEBUG_LEVEL, &ival );
if ( argc < 2 ) {
usage( argv[0] );
return( EXIT_FAILURE );
}
#ifdef HAVE_CONSOLE_H
ccommand( &argv );
cshow( stdout );
#endif
sb = ber_sockbuf_alloc();
fd = fileno( stdin );
ber_sockbuf_add_io( sb, &ber_sockbuf_io_fd, LBER_SBIOD_LEVEL_PROVIDER,
(void *)&fd );
ber = ber_alloc_t(LBER_USE_DER);
if( ber == NULL ) {
perror( "ber_alloc_t" );
return( EXIT_FAILURE );
}
for (;;) {
tag = ber_get_next( sb, &len, ber);
if( tag != LBER_ERROR ) break;
if( errno == EWOULDBLOCK ) continue;
if( errno == EAGAIN ) continue;
perror( "ber_get_next" );
return( EXIT_FAILURE );
}
printf("decode: message tag 0x%lx and length %ld\n",
(unsigned long) tag, (long) len );
for( s = argv[1]; *s; s++ ) {
char buf[128];
char fmt[2];
fmt[0] = *s;
fmt[1] = '\0';
printf("decode: format %s\n", fmt );
len = sizeof(buf);
tag = ber_scanf( ber, fmt, &buf[0], &len );
if( tag == LBER_ERROR ) {
perror( "ber_scanf" );
return( EXIT_FAILURE );
}
}
ber_sockbuf_free( sb );
return( EXIT_SUCCESS );
}
