Ejemplo n.º 1
0
   // PD_TRACE_DECLARE_FUNCTION ( SDB__MIGLOADJSONPS__INITIALIZE, "migMaster::initialize" )
   INT32 migMaster::initialize ( setParameters *pParameters )
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY ( SDB__MIGLOADJSONPS__INITIALIZE );
      _utilParserParamet parserPara ;
      UINT32  startOffset = 0 ;
      UINT32  fieldsSize  = 0 ;

      _pParameters = pParameters ;
      _sock = _pParameters->clientSock ;
      _fileType = _pParameters->fileType ;
      _blockSize = _pParameters->bufferSize/_pParameters->bucketNum ;
      _exitSignal = FALSE ;

      if ( MIG_PARSER_JSON == _pParameters->fileType )
      {
         _parser = SDB_OSS_NEW _utilJSONParser() ;
      }
      else if ( MIG_PARSER_CSV == _pParameters->fileType )
      {
         _parser = SDB_OSS_NEW _utilCSVParser() ;
      }
      else
      {
         rc = SDB_MIG_UNKNOW_FILE_TYPE ;
         PD_LOG ( PDERROR, "Unknow file type" ) ;
         goto error ;
      }
      PD_CHECK ( _parser, SDB_OOM, error, PDERROR,
                 "Failed to new _parser" ) ;
      _ppBucket = (_bucket**)SDB_OSS_MALLOC ( sizeof(_bucket*) *
                                              _pParameters->bucketNum ) ;
      PD_CHECK ( _ppBucket, SDB_OOM, error, PDERROR,
                 "Failed to allocate bucket pointer array" ) ;
      ossMemset ( _ppBucket, 0, sizeof(_bucket*) * _pParameters->bucketNum ) ;
      for ( UINT32 i = 0; i < _pParameters->bucketNum; ++i )
      {
         _ppBucket[i] = SDB_OSS_NEW _bucket() ;
         PD_CHECK ( _ppBucket[i], SDB_OOM, error, PDERROR,
                    "Failed to allocate bucket pointer array" ) ;
      }

      _parser->setDel ( _pParameters->delCFR[0],
                        _pParameters->delCFR[1],
                        _pParameters->delCFR[2] ) ;

      parserPara.fileName = _pParameters->pFileName ;
      parserPara.bufferSize = _pParameters->bufferSize ;
      parserPara.blockNum = _pParameters->bucketNum ;

      rc = _parser->initialize( &parserPara ) ;
      if ( rc )
      {
         PD_LOG ( PDERROR, "Failed to init utilParseJSONs, rc = %d", rc ) ;
         if ( SDB_IO == rc || SDB_FNE == rc )
         {
            sendMsgToClient ( "Failed to open file %s, rc=%d",
                              _pParameters->pFileName, rc ) ;
         }
         goto error ;
      }
      _buffer = _parser->getBuffer() ;

      _delChar   = _pParameters->delCFR[0] ;
      _delField  = _pParameters->delCFR[1] ;
      _delRecord = _pParameters->delCFR[2] ;
      _autoAddField   = TRUE ;
      _autoCompletion = FALSE ;
      _isHeaderline   = _pParameters->headerline ;
      

      if ( _isHeaderline )
      {
         rc = _parser->getNextRecord ( startOffset, fieldsSize ) ;
         if ( rc )
         {
            if ( rc == SDB_EOF )
            {
               if ( 0 == fieldsSize )
               {
                  goto done ;
               }
            }
            else
            {
               PD_LOG ( PDERROR, "Failed to _parser getNextRecord, rc=%d", rc ) ;
               goto error ;
            }
         }
      }
      
      if ( _pParameters->pFieldArray )
      {
         _pFields = _pParameters->pFieldArray ;
         _fieldsSize = ossStrlen( _pFields ) ;
      }
      else
      {
         _pFields = _buffer + startOffset ;
         _fieldsSize = fieldsSize ;
      }

   done:
      PD_TRACE_EXITRC ( SDB__MIGLOADJSONPS__INITIALIZE, rc );
      return rc ;
   error:
      goto done ;
   }
Ejemplo n.º 2
0
INT32 _appendValue( CHAR delChar, bson_iterator *pIt,
                    CHAR **ppBuffer, INT32 *pCSVSize,
                    BOOLEAN includeBinary,
                    BOOLEAN includeRegex )
{
    INT32 rc = SDB_OK ;
    bson_type type = bson_iterator_type( pIt ) ;
    INT32 tempSize = 0 ;
    INT32 base64Size = 0 ;
    INT32 binType = 0 ;
    CHAR temp[128] = { 0 } ;
    const CHAR *pTemp = NULL ;
    CHAR *pBase64 = NULL ;
    bson_timestamp_t ts;
    time_t timer ;
    struct tm psr;

    if ( type == BSON_DOUBLE || type == BSON_BOOL ||
            type == BSON_NULL || type == BSON_INT ||
            type == BSON_LONG )
    {
        rc = _appendNonString( delChar, pIt, ppBuffer, pCSVSize ) ;
        if ( rc )
        {
            goto error ;
        }
    }
    else
    {
        rc = _appendString( delChar, &delChar, 1, ppBuffer, pCSVSize ) ;
        if ( rc )
        {
            goto error ;
        }
        if ( type == BSON_TIMESTAMP )
        {
            ts = bson_iterator_timestamp( pIt ) ;
            timer = (time_t)ts.t;
            local_time( &timer, &psr ) ;
            tempSize = ossSnprintf ( temp, 64,
                                     "%04d-%02d-%02d-%02d.%02d.%02d.%06d",
                                     psr.tm_year + 1900,
                                     psr.tm_mon + 1,
                                     psr.tm_mday,
                                     psr.tm_hour,
                                     psr.tm_min,
                                     psr.tm_sec,
                                     ts.i ) ;
            rc = _appendString( delChar, temp, tempSize, ppBuffer, pCSVSize ) ;
            if ( rc )
            {
                goto error ;
            }
        }
        else if ( type == BSON_DATE )
        {
            timer = bson_iterator_date( pIt ) / 1000 ;
            local_time( &timer, &psr ) ;
            tempSize = ossSnprintf ( temp, 64, "%04d-%02d-%02d",
                                     psr.tm_year + 1900,
                                     psr.tm_mon + 1,
                                     psr.tm_mday ) ;
            rc = _appendString( delChar, temp, tempSize, ppBuffer, pCSVSize ) ;
            if ( rc )
            {
                goto error ;
            }
        }
        else if ( type == BSON_UNDEFINED )
        {
            rc = _appendString( delChar, CSV_STR_UNDEFINED,
                                CSV_STR_UNDEFINED_SIZE,
                                ppBuffer, pCSVSize ) ;
            if ( rc )
            {
                goto error ;
            }
        }
        else if ( type == BSON_MINKEY )
        {
            rc = _appendString( delChar, CSV_STR_MINKEY,
                                CSV_STR_MINKEY_SIZE, ppBuffer, pCSVSize ) ;
            if ( rc )
            {
                goto error ;
            }
        }
        else if ( type == BSON_MAXKEY )
        {
            rc = _appendString( delChar, CSV_STR_MAXKEY,
                                CSV_STR_MAXKEY_SIZE, ppBuffer, pCSVSize ) ;
            if ( rc )
            {
                goto error ;
            }
        }
        else if ( type == BSON_CODE )
        {
            pTemp = bson_iterator_code( pIt ) ;
            rc = _appendString( delChar, pTemp, ossStrlen( pTemp ),
                                ppBuffer, pCSVSize ) ;
            if ( rc )
            {
                goto error ;
            }
        }
        else if ( type == BSON_STRING || type == BSON_SYMBOL )
        {
            pTemp = bson_iterator_string( pIt ) ;
            rc = _appendString( delChar, pTemp, ossStrlen( pTemp ),
                                ppBuffer, pCSVSize ) ;
            if ( rc )
            {
                goto error ;
            }
        }
        else if ( type == BSON_BINDATA )
        {
            if( TRUE == includeBinary )
            {
                rc = _appendString( delChar, CSV_STR_LEFTBRACKET, 1, ppBuffer, pCSVSize ) ;
                if ( rc )
                {
                    goto error ;
                }
                binType = (INT32)bson_iterator_bin_type( pIt ) ;
                tempSize = ossSnprintf ( temp, 64, "%d", binType ) ;
                rc = _appendString( delChar, &temp, tempSize, ppBuffer, pCSVSize ) ;
                if ( rc )
                {
                    goto error ;
                }
                rc = _appendString( delChar, CSV_STR_RIGHTBRACKET, 1, ppBuffer, pCSVSize ) ;
                if ( rc )
                {
                    goto error ;
                }
            }
            pTemp = bson_iterator_bin_data( pIt ) ;
            tempSize = bson_iterator_bin_len ( pIt ) ;
            if( tempSize > 0 )
            {
                base64Size = getEnBase64Size ( tempSize ) ;
                pBase64 = (CHAR *)SDB_OSS_MALLOC( base64Size ) ;
                if( NULL == pBase64 )
                {
                    rc = SDB_OOM ;
                    goto error ;
                }
                ossMemset( pBase64, 0, base64Size ) ;
                if ( base64Encode( pTemp, tempSize, pBase64, base64Size ) < 0 )
                {
                    rc = SDB_OOM ;
                    goto error ;
                }
                rc = _appendString( delChar, pBase64, base64Size - 1,
                                    ppBuffer, pCSVSize ) ;
                if ( rc )
                {
                    goto error ;
                }
            }
        }
        else if ( type == BSON_REGEX )
        {
            if( TRUE == includeRegex )
            {
                rc = _appendString( delChar, CSV_STR_BACKSLASH, 1,
                                    ppBuffer, pCSVSize ) ;
                if ( rc )
                {
                    goto error ;
                }
            }
            pTemp = bson_iterator_regex( pIt ) ;
            rc = _appendString( delChar, pTemp, ossStrlen( pTemp ),
                                ppBuffer, pCSVSize ) ;
            if ( rc )
            {
                goto error ;
            }
            if( TRUE == includeRegex )
            {
                rc = _appendString( delChar, CSV_STR_BACKSLASH, 1,
                                    ppBuffer, pCSVSize ) ;
                if ( rc )
                {
                    goto error ;
                }
                pTemp = bson_iterator_regex_opts( pIt ) ;
                rc = _appendString( delChar, pTemp, ossStrlen( pTemp ),
                                    ppBuffer, pCSVSize ) ;
                if ( rc )
                {
                    goto error ;
                }
            }
        }
        else if ( type == BSON_OID )
        {
            bson_oid_to_string( bson_iterator_oid( pIt ), temp ) ;
            rc = _appendString( delChar, temp, 24, ppBuffer, pCSVSize ) ;
            if ( rc )
            {
                goto error ;
            }
        }
        else
        {
            rc = _appendObj( delChar, pIt, ppBuffer, pCSVSize ) ;
            if ( rc )
            {
                goto error ;
            }
        }
        rc = _appendString( delChar, &delChar, 1, ppBuffer, pCSVSize ) ;
        if ( rc )
        {
            goto error ;
        }
    }
done:
    SAFE_OSS_FREE( pBase64 ) ;
    return rc ;
error:
    goto done ;
}
Ejemplo n.º 3
0
 _ciCollection() : _next( NULL )
 {
    ossMemset( _clName, 0, CI_CL_FULLNAME_SIZE + 1 ) ;
    ossMemset( _mainClName, 0, CI_CL_FULLNAME_SIZE + 1 ) ;
    ossMemcpy( _mainClName, NONE_NAME, ossStrlen( NONE_NAME ) ) ;
 }
Ejemplo n.º 4
0
INT32 restAdaptor::setOPResult( pmdRestSession *pSession,
                                INT32 result,
                                const BSONObj &info )
{
    INT32 rc = SDB_OK ;
    PD_TRACE_ENTRY( SDB__RESTADP_SETOPR ) ;
    SDB_ASSERT ( pSession, "pSession is NULL" ) ;
    httpConnection *pHttpCon = pSession->getRestConn() ;

    if( COM_GETFILE != pHttpCon->_common )
    {
        std::string str = info.toString( FALSE, TRUE ) ;
        INT32 bufferSize = ossStrlen( str.c_str() ) ;
        if( TRUE == pHttpCon->_isChunk )
        {
            if( FALSE == pHttpCon->_isSendHttpHeader )
            {
                pHttpCon->_isSendHttpHeader = TRUE ;
                rc = _setResponseType( pSession ) ;
                if( rc )
                {
                    PD_LOG ( PDERROR, "Failed to set respone type, rc=%d",
                             rc ) ;
                    goto error ;
                }
                rc = _sendHttpHeader( pSession, HTTP_OK ) ;
                if ( rc )
                {
                    PD_LOG ( PDERROR, "Failed to send http header, rc=%d", rc ) ;
                    goto error ;
                }
            }
            rc = _sendHttpChunk( pSession, str.c_str(), bufferSize ) ;
            if( rc )
            {
                PD_LOG ( PDERROR, "Failed to send http chunk, rc=%d", rc ) ;
                goto error ;
            }
        }
        else
        {
            CHAR *pBuffer = NULL ;
            INT32 tempSize = 0 ;
            httpResponse httpRe ;
            rc = pSession->allocBuff( bufferSize + 1, &pBuffer, tempSize ) ;
            if ( rc )
            {
                PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
                         bufferSize + 1, rc ) ;
                goto error ;
            }
            ossMemcpy( pBuffer, str.c_str(), bufferSize ) ;
            pBuffer[ bufferSize ] = 0 ;
            pHttpCon->_firstRecordSize = bufferSize ;
            httpRe.pBuffer = pBuffer ;
            httpRe.len = bufferSize ;
            pHttpCon->_responseBody[0] = httpRe ;
        }
    }
done:
    PD_TRACE_EXITRC( SDB__RESTADP_SETOPR, rc ) ;
    return rc ;
error:
    goto done ;
}
Ejemplo n.º 5
0
INT32 restAdaptor::_convertMsg( pmdRestSession *pSession,
                                HTTP_PARSE_COMMON &common,
                                CHAR **ppMsg,
                                INT32 &msgSize )
{
    INT32 rc = SDB_OK ;
    PD_TRACE_ENTRY( SDB__RESTADP_CONVERTMSG );
    SDB_ASSERT ( pSession, "pSession is NULL" ) ;
    SDB_ASSERT ( ppMsg, "pMsg is NULL" ) ;
    INT32 pathSize = 0 ;
    INT32 tempSize = 0 ;
    INT32 extenSize = 0 ;
    const CHAR *pFileName = NULL ;
    const CHAR *pExtension = NULL ;
    CHAR *pMsg = NULL ;
    httpConnection *pHttpCon = pSession->getRestConn() ;

    if( pHttpCon->_pPath )
    {
        pFileName = _getResourceFileName( pHttpCon->_pPath ) ;
    }
    if ( pFileName )
    {
        common = COM_GETFILE ;
        pHttpCon->_fileType = HTTP_FILE_UNKNOW ;
        pExtension = _getFileExtension( pFileName ) ;
        if ( pExtension )
        {
            extenSize = ossStrlen( pExtension ) ;
            for( UINT32 i = 0; i < REST_STRING_FILE_EX_SIZE; ++i )
            {
                if ( 0 == ossStrncasecmp( pExtension,
                                          fileExtension[i], extenSize ) )
                {
                    pHttpCon->_fileType = (HTTP_FILE_TYPE)i ;
                    break ;
                }
            }
        }
    }
    else
    {
        if ( pHttpCon->_requestQuery.size() > 0 )
        {
            common = COM_CMD ;
            pHttpCon->_fileType = HTTP_FILE_HTML ;
        }
        else
        {
            common = COM_GETFILE ;
            pHttpCon->_fileType = HTTP_FILE_DEFAULT ;
        }
    }
    if( pHttpCon->_pPath )
    {
        pathSize = ossStrlen( pHttpCon->_pPath ) ;
        rc = pSession->allocBuff( pathSize + 1, &pMsg, tempSize ) ;
        if ( rc )
        {
            PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
                     pathSize, rc ) ;
            goto error ;
        }
        ossMemcpy( pMsg, pHttpCon->_pPath, pathSize ) ;
        pMsg[pathSize] = 0 ;
    }
    else
    {
        pathSize = 1 ;
        rc = pSession->allocBuff( pathSize + 1, &pMsg, tempSize ) ;
        if ( rc )
        {
            PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
                     pathSize, rc ) ;
            goto error ;
        }
        pMsg[0] = '/' ;
        pMsg[1] = 0 ;
    }
    *ppMsg = pMsg ;
    msgSize = pathSize ;
done:
    PD_TRACE_EXITRC ( SDB__RESTADP_CONVERTMSG, rc ) ;
    return rc ;
error:
    goto done ;
}
Ejemplo n.º 6
0
INT32 restAdaptor::appendHttpBody( pmdRestSession *pSession,
                                   const CHAR *pBuffer,
                                   INT32 length,
                                   INT32 number, BOOLEAN isObjBuffer )
{
    INT32 rc = SDB_OK ;
    PD_TRACE_ENTRY( SDB__RESTADP_APPENDBODY ) ;
    SDB_ASSERT ( pSession, "pSession is NULL" ) ;
    SDB_ASSERT ( pBuffer, "pBuffer is NULL" ) ;
    httpConnection *pHttpCon = pSession->getRestConn() ;
    INT32 tempSize = 0 ;
    httpResponse httpRe ;

    if( TRUE == pHttpCon->_isChunk )
    {
        if( FALSE == pHttpCon->_isSendHttpHeader )
        {
            pHttpCon->_isSendHttpHeader = TRUE ;
            rc = _setResponseType( pSession ) ;
            if( rc )
            {
                PD_LOG ( PDERROR, "Failed to set respone type, rc=%d",
                         rc ) ;
                goto error ;
            }
            rc = _sendHttpHeader( pSession, HTTP_OK ) ;
            if ( rc )
            {
                PD_LOG ( PDERROR, "Failed to send http header, rc=%d", rc ) ;
                goto error ;
            }
        }

        if( isObjBuffer )
        {
            INT32 jsonSize = 0 ;
            BSONObj record ;
            std::string str ;
            _rtnObjBuff rtnObj( pBuffer, length, number ) ;

            while( TRUE )
            {
                rc = rtnObj.nextObj( record ) ;
                if ( SDB_DMS_EOC == rc )
                {
                    rc = SDB_OK ;
                    break ;
                }
                else if ( SDB_SYS == rc )
                {
                    PD_LOG ( PDERROR, "Failed to get nextObj:rc=%d", rc ) ;
                    goto error ;
                }

                str = record.toString( FALSE, TRUE ) ;
                jsonSize = ossStrlen( str.c_str() ) ;
                rc = _sendHttpChunk( pSession, str.c_str(), jsonSize ) ;
                if( rc )
                {
                    PD_LOG ( PDERROR, "Failed to send http chunk, rc=%d", rc ) ;
                    goto error ;
                }
            }
        }
        else
        {
            rc = _sendHttpChunk( pSession, pBuffer, length ) ;
            if( rc )
            {
                PD_LOG ( PDERROR, "Failed to send http chunk, rc=%d", rc ) ;
                goto error ;
            }
        }
    }
    else
    {
        if( isObjBuffer )
        {
            CHAR *pJson = NULL ;
            INT32 jsonSize = 0 ;
            BSONObj record ;
            std::string str ;
            _rtnObjBuff rtnObj( pBuffer, length, number ) ;

            while( TRUE )
            {
                rc = rtnObj.nextObj( record ) ;
                if ( SDB_DMS_EOC == rc )
                {
                    rc = SDB_OK ;
                    break ;
                }
                else if ( SDB_SYS == rc )
                {
                    PD_LOG ( PDERROR, "Failed to get nextObj:rc=%d", rc ) ;
                    goto error ;
                }

                str = record.toString( FALSE, TRUE ) ;
                jsonSize = ossStrlen( str.c_str() ) ;
                rc = pSession->allocBuff( jsonSize + 1, &pJson, tempSize ) ;
                if ( rc )
                {
                    PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
                             jsonSize + 1, rc ) ;
                    goto error ;
                }
                ossMemcpy( pJson, str.c_str(), jsonSize ) ;
                pJson[ jsonSize ] = 0 ;
                pHttpCon->_responseSize += jsonSize ;
                httpRe.pBuffer = pJson ;
                httpRe.len = jsonSize ;
                pHttpCon->_responseBody.push_back( httpRe ) ;
                pBuffer = NULL ;
                jsonSize = 0 ;
            }
        }
        else
        {
            CHAR *pFileText = NULL ;
            rc = pSession->allocBuff( length + 1, &pFileText, tempSize ) ;
            if ( rc )
            {
                PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
                         length + 1, rc ) ;
                goto error ;
            }
            ossMemcpy( pFileText, pBuffer, length ) ;
            pFileText[ length ] = 0 ;
            pHttpCon->_firstRecordSize = length ;
            httpRe.pBuffer = pFileText ;
            httpRe.len = length ;
            pHttpCon->_responseBody[0] = httpRe ;
        }
    }
done:
    PD_TRACE_EXITRC( SDB__RESTADP_APPENDBODY, rc ) ;
    return rc ;
error:
    goto done ;
}
Ejemplo n.º 7
0
INT32 restAdaptor::appendHttpHeader( pmdRestSession *pSession,
                                     const CHAR *pKey,
                                     const CHAR *pValue )
{
    INT32 rc = SDB_OK ;
    PD_TRACE_ENTRY( SDB__RESTADP_APPENDHEADER ) ;
    SDB_ASSERT ( pSession, "pSession is NULL" ) ;
    INT32 keySize = ossStrlen( pKey ) ;
    INT32 valueSize = ossStrlen( pValue ) ;
    INT32 newHeaderSize = keySize + valueSize + 2 ;
    INT32 tempSize = 0 ;
    CHAR *pNewHeaderBuf = NULL ;
    CHAR *pNewKey = NULL ;
    CHAR *pNewValue = NULL ;
    httpConnection *pHttpCon = pSession->getRestConn() ;
    COLNAME_MAP_IT it ;

    if( REST_STRING_TRANSFER_SIZE == ossStrlen( pKey ) &&
            0 == ossStrncmp( pKey, REST_STRING_TRANSFER,
                             REST_STRING_TRANSFER_SIZE ) &&
            REST_STRING_CHUNKED_SIZE == ossStrlen( pValue ) &&
            0 == ossStrncmp( pValue, REST_STRING_CHUNKED,
                             REST_STRING_CHUNKED_SIZE ) )
    {
        pHttpCon->_isChunk = TRUE ;
    }

    it = pHttpCon->_responseHeaders.find( pKey ) ;
    if ( it == pHttpCon->_responseHeaders.end() )
    {
        rc = pSession->allocBuff( newHeaderSize, &pNewHeaderBuf, tempSize ) ;
        if ( rc )
        {
            PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
                     newHeaderSize, rc ) ;
            goto error ;
        }

        pNewKey = pNewHeaderBuf ;
        pNewValue = pNewHeaderBuf + keySize + 1 ;
        ossStrncpy( pNewKey, pKey, keySize ) ;
        ossStrncpy( pNewValue, pValue, valueSize ) ;
        pNewKey[ keySize ] = 0 ;
        pNewValue[ valueSize ] = 0 ;
        pHttpCon->_responseHeaders.insert(
            std::make_pair( pNewKey, pNewValue ) ) ;
    }
    else
    {
        rc = pSession->allocBuff( valueSize + 1, &pNewValue, tempSize ) ;
        if ( rc )
        {
            PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
                     valueSize, rc ) ;
            goto error ;
        }
        ossStrncpy( pNewValue, pValue, valueSize ) ;
        pNewValue[ valueSize ] = 0 ;
        it->second = pNewValue ;
    }

done:
    PD_TRACE_EXITRC( SDB__RESTADP_APPENDHEADER, rc ) ;
    return rc ;
error:
    goto done ;
}
Ejemplo n.º 8
0
   void omClusterNotifier::_getAgentService( string &serviceName )
   {
      INT32 rc = SDB_OK ;
      CHAR conf[OSS_MAX_PATHSIZE + 1] = { 0 } ;
      po::options_description desc ( "Config options" ) ;
      po::variables_map vm ;
      CHAR hostport[OSS_MAX_HOSTNAME + 6] = { 0 } ;
      serviceName = boost::lexical_cast<string>( SDBCM_DFT_PORT ) ;
      rc = ossGetHostName( hostport, OSS_MAX_HOSTNAME ) ;
      if ( rc != SDB_OK )
      {
         PD_LOG( PDERROR, "get host name failed:rc=%d", rc ) ;
         goto error ;
      }

      ossStrncat ( hostport, SDBCM_CONF_PORT, ossStrlen(SDBCM_CONF_PORT) ) ;

      desc.add_options()
         (SDBCM_CONF_DFTPORT, po::value<string>(), "sdbcm default "
         "listening port")
         (hostport, po::value<string>(), "sdbcm specified listening port")
      ;

      rc = ossGetEWD ( conf, OSS_MAX_PATHSIZE ) ;
      if ( rc )
      {
         PD_LOG ( PDERROR, "Failed to get excutable file's working "
                  "directory" ) ;
         goto error ;
      }

      if ( ( ossStrlen ( conf ) + ossStrlen ( SDBCM_CONF_PATH_FILE ) + 2 ) >
           OSS_MAX_PATHSIZE )
      {
         PD_LOG ( PDERROR, "Working directory too long" ) ;
         rc = SDB_INVALIDARG ;
         goto error ;
      }

      ossStrncat( conf, OSS_FILE_SEP, 1 );
      ossStrncat( conf, SDBCM_CONF_PATH_FILE,
                  ossStrlen( SDBCM_CONF_PATH_FILE ) );
      rc = utilReadConfigureFile ( conf, desc, vm ) ;
      if ( rc )
      {
         PD_LOG ( PDERROR, "Failed to read configure file, rc = %d", rc ) ;
         goto error ;
      }
      else if ( vm.count( hostport ) )
      {
         serviceName = vm[hostport].as<string>() ;
      }
      else if ( vm.count( SDBCM_CONF_DFTPORT ) )
      {
         serviceName = vm[SDBCM_CONF_DFTPORT].as<string>() ;
      }
      else
      {
         serviceName = boost::lexical_cast<string>( SDBCM_DFT_PORT ) ;
      }

   done:
      return ;
   error:
      goto done ;
   }