socket resource exhaust

The slice：
module ied
{
struct GETFILE
{
string remoteFile;
string localFile;
};
sequence GetFileSeq;

    struct FILEATTR
    {
        string fileName;
        string filePath;
        int    fileSize;
        long   fileLastModified;
    };
    sequence<FILEATTR> FileAttrSeq;

    interface iedFile
    {
        bool connected(string ip, int port);
        bool readFile(string ip, int port, string remotefile, string localfile);
        bool readFiles(string ip, int port, GetFileSeq files, out string failedfile);
        bool readComtradeDirectory(string ip, int port, string dirname, string caname, out FileAttrSeq seq);
        bool readDirectory(string ip, int port, string dirname, string caname, out FileAttrSeq seq);
    };
};

The ice server app run function:
int CFile850App::run(int argc, char* argv[])
{
//This function creates an IceUtil::CtrlCHandler that shuts down the
//communicator when one of the monitored signals is raised.
shutdownOnInterrupt();

    m_communicator = communicator();
    m_adapterIedFile = m_communicator->createObjectAdapterWithEndpoints((string)("IedFile"), (string)("default -p 10012"));
    CIedFileIPtr iedfileiptr = new CIedFileI();
    m_adapterIedFile->add(iedfileiptr, communicator()->stringToIdentity("IedFile"));
    m_adapterIedFile->activate();

    try
    {
        m_communicator->waitForShutdown();
    }
    catch (const Ice::Exception& e)
    {
        cerr << e << endl;
    }

    if (communicator())
    {
        try
        {
            communicator()->destroy();
        }
        catch (const Ice::Exception& e)
        {
            cerr << e << endl;
        }
    }

    return EXIT_SUCCESS;
}

The ice server side interface implementation:
bool CIedFileI::connected(const ::std::string& ip, ::Ice::Int port, const ::Ice::Current& cur /* = Ice::Current() */)
{
SdlIec61850Client client(ip, port);
bool ret = client.initialize();
return ret;
}

bool CIedFileI::readFile(const ::std::string& ip, ::Ice::Int port, const ::std::string& remoteFile, const ::std::string& localFile, const ::Ice::Current& cur /* = Ice::Current() */)
{
    SdlIec61850Client client(ip, port);
    bool ret = client.initialize();
    if (!ret)
        return ret;

    ret = client.get_file(remoteFile, localFile);
    return ret;
}

bool CIedFileI::readFiles(const ::std::string& ip, ::Ice::Int port, const ::ied::GetFileSeq& files, ::std::string& failedfile, const ::Ice::Current& cur /* = Ice::Current() */)
{
    SdlIec61850Client client(ip, port);
    bool ret = client.initialize();
    if (!ret)
        return false;

    ::ied::GetFileSeq::const_iterator iter;
    for (iter = files.begin(); iter != files.end(); ++iter)
    {
        ret = client.get_file(iter->remoteFile, iter->localFile);
        if (!ret)
        {
            failedfile = iter->remoteFile;
            return false;
        }
    }
    return true;
}

SdlIec61850Client is a client for getting data from IEC61850 server. It is written using libiec61850 library. I use libiec61850 in other programs. It works ok. So the socket leak can not caused by libiec61850. In my program file850, only ice and libiec61850 use socket, I didn't write any socket code.

The ice client side code:
iedFilePrx CShandong850I::get_iedfile_proxy()
{
try
{
string strUri = "IedFile:default -h 127.0.0.1 -p 10012";
Ice::CommunicatorPtr communicatorPtr = Ice::Application::communicator();
Ice::ObjectPrx objPrx = communicatorPtr->stringToProxy(strUri);
iedFilePrx filePrx = iedFilePrx::checkedCast(objPrx);
return filePrx;
}
catch (Ice::LocalException& e)
{
if (strstr(e.what(), "ConnectTimeoutException") != NULL)
{
kill_file850_program();
}
return NULL;
}
catch (Ice::Exception& e)
{
m_log.WriteALog(e.what());
return NULL;
}
catch (...)
{
m_log.WriteALog("readDirectory: unknown exception");
return NULL;
}

    return NULL;
}

bool CShandong850I::is_connected()
{
    try
    {
        iedFilePrx filePrx= get_iedfile_proxy();
        if(filePrx == NULL)
            return false;

        string ip = (m_ied.valid_ip_no == 1)? m_ied.ip1 : m_ied.ip2;
        int32_t port = (m_ied.valid_ip_no == 1)? m_ied.port1 : m_ied.port2;

        iedFilePrx timeoutFilePrx = filePrx->ice_invocationTimeout(600000);         
        bool ret = timeoutFilePrx->connected(ip, port);
        return ret;
    }
    catch (Ice::InvocationTimeoutException& e)
    {
        return false;
    }
    catch(Ice::LocalException& e)
    {
        return false;
    }
    catch(Ice::Exception& e)
    {
        return false;
    }
    catch(...)
    {
        return false;
    }
    return false;
}

bool CShandong850I::get_comtrade_files_async(COMTRADE_FILE_ATTRIBUTE* comtrade_file_attribute, char* dst_file_name, string& failed_file, CLog* log/*=NULL*/)
{
    failed_file = "";
    string srcFileName;
    if (comtrade_file_attribute->file_name[0] == '/')
        srcFileName = comtrade_file_attribute->file_name;
    else
    {
        srcFileName = "/COMTRADE/";
        srcFileName += comtrade_file_attribute->file_name;
    }
    string dstFileName = dst_file_name;
    string srcDatFile = srcFileName + comtrade_file_attribute->dat_suffix;
    string srcCfgFile = srcFileName + comtrade_file_attribute->cfg_suffix;
    string srcHdrFile = srcFileName + comtrade_file_attribute->hdr_suffix;
    string srcDmfFile = srcFileName + comtrade_file_attribute->dmf_suffix;
    string dstDatFile = dstFileName + ".dat";
    string dstCfgFile = dstFileName + ".cfg";
    string dstHdrFile = dstFileName + ".hdr";
    string dstDmfFile = dstFileName + ".dmf";

    GetFileSeq files;
    ::ied::GETFILE get_file;
    get_file.remoteFile = srcCfgFile;
    get_file.localFile = dstCfgFile;
    files.push_back(get_file);
    get_file.remoteFile = srcDatFile;
    get_file.localFile = dstDatFile;
    files.push_back(get_file);
    if (strlen(comtrade_file_attribute->hdr_suffix) > 0)
    {
        get_file.remoteFile = srcHdrFile;
        get_file.localFile = dstHdrFile;
        files.push_back(get_file);
    }
    if (strlen(comtrade_file_attribute->dmf_suffix) > 0)
    {
        get_file.remoteFile = srcDmfFile;
        get_file.localFile = dstDmfFile;
        files.push_back(get_file);
    }

    int32_t ice_override_timeout = CEnvironment::get_env()->get_ice_override_timeout();
    int32_t loop_times = ice_override_timeout / 50 + 1;
    iedFilePrx filePrx = get_iedfile_proxy();
    if (filePrx == NULL)
    {
        failed_file = "connect to file850 failed";
        return false;
    }

    string ip = (m_ied.valid_ip_no == 1) ? m_ied.ip1 : m_ied.ip2;
    int32_t port = (m_ied.valid_ip_no == 1) ? m_ied.port1 : m_ied.port2;

    try
    {
        iedFilePrx timeoutFilePrx = filePrx->ice_invocationTimeout(ice_override_timeout);

        Ice::AsyncResultPtr resultPtr = timeoutFilePrx->begin_readFiles(ip, port, files);
        resultPtr->waitForSent();

        for (int i = 0; i < loop_times; ++i)
        {
            if (!resultPtr->isCompleted())
            {
                MySleep(50000); // sleep 50 ms
                continue;
            }

            bool ret = timeoutFilePrx->end_readFiles(failed_file, resultPtr);
            if (!ret)
            {
                MyDeleteFile(dstDatFile.c_str());
                MyDeleteFile(dstCfgFile.c_str());
                MyDeleteFile(dstHdrFile.c_str());
                MyDeleteFile(dstDmfFile.c_str());
            }
            return ret;
        }

        //调用ice接口超时
        MyDeleteFile(dstDatFile.c_str());
        MyDeleteFile(dstCfgFile.c_str());
        MyDeleteFile(dstHdrFile.c_str());
        MyDeleteFile(dstDmfFile.c_str());
    }
    catch (Ice::InvocationTimeoutException& e)
    {
        return false;
    }
    catch (Ice::LocalException& e)
    {
        return false;
    }
    catch (Ice::Exception& e)
    {
        return false;
    }
    catch (...)
    {
        return false;
    }
    return false;
}

The ice client side program, having more than 100 threads. These threads mutual independence. All threads will send ice call to ice server from code above.

Hi,
Thanks very mush.
I write a test server and client. It works well. It perhaps libIEC61850's problem.