IE 的问题确实比较多, 我还记得一个牛人调试过, 得出的结论

怀疑某个地方 m_MSHTML->Release()之后, m_MSHTML没有设置为空, 析构函数中再次Release就出错了

引用:

原帖由 wsg1212 于 2008-2-28 16:42 发表
ThtmlParser::ThtmlParser(const char* baseurl, const char* html, bool bfollow)
{
        if (m_MSHTML)
                m_MSHTML->Release();

if (m_MSHTML)
                {
                    m_MSHTML->Release();
                   m_MSHTML=0;
}

指针RELEASE了，不一定为0

应该不是这个问题，大约3个小时出现一次吧。

代码反复执行的，感觉就是MS的BUG

找到了一个方法，就是_try except，捕捉大错误后，重新启动。

引用:

原帖由 wsg1212 于 2008-2-29 15:59 发表
找到了一个方法，就是_try except，捕捉大错误后，重新启动。

不如做成另一个进程处理，这样也不需要重新启动。

死掉也没有关系，只要不破坏数据，

long get_urlscheme(const char* url)
{
        URL_COMPONENTS components = {0};
        components.dwStructSize = sizeof(components);
        InternetCrackUrl(url, 0, 0, &components);
        return components.nScheme;
}

long get_urlport(const char* url)
{
        URL_COMPONENTS components = {0};
        components.dwStructSize = sizeof(components);
        InternetCrackUrl(url, 0, 0, &components);
        return components.nPort;
}

char* get_urlpath(const char* url, char* urlpath)
{
        URL_COMPONENTS components = {0};
        components.dwStructSize = sizeof(components);
        components.lpszUrlPath = urlpath;
        components.dwUrlPathLength = MAX_URL;
        InternetCrackUrl(url, 0, 0, &components);
        return urlpath;
}

char* get_urlextrainfo(const char* url, char* extrainfo)
{
        URL_COMPONENTS components = {0};
        components.dwStructSize = sizeof(components);
        components.lpszExtraInfo = extrainfo;
        components.dwExtraInfoLength = MAX_URL;
        InternetCrackUrl(url, 0, 0, &components);
        return extrainfo;
}

char* get_urlhostname(const char* url, char* hostname)
{
        URL_COMPONENTS components = {0};
        components.dwStructSize = sizeof(components);
        components.lpszHostName = hostname;
        components.dwHostNameLength = MAX_URL;
        InternetCrackUrl(url, 0, 0, &components);
        return hostname;
}

bool is_validurl(const char* url)
{
        WCHAR w_url [MAX_URL] = {0};

        MultiByteToWideChar(CP_THREAD_ACP, 0, url, strlen(url), w_url, sizeof(w_url));

        if (IsValidURL(NULL, w_url, 0) == S_OK)
        {
                switch (get_urlscheme(url))
                {
                case INTERNET_SCHEME_HTTP:
                case INTERNET_SCHEME_HTTPS:
                        return true;
                default:
                        return false;
                }
        }

        return false;
}

bool is_subdomain(const char* parent, const char* child)
{
        string _parent = parent;
        string _child = child;
        int pos = _child.rfind(parent);
        if (pos != -1) {
                if (pos + _parent.length() == _child.length())
                        return true;
        }

        return false;
}

unsigned int hash_url(const char* url)
{
        unsigned int hash = 0;
        unsigned char *p;
        for (hash=0, p = (unsigned char *)url; *p ; p++)
                hash = 31 * hash + *p;
        return hash;
}

char* remove_urlquery(char* url)
{
        char* p = strchr(url, '?');
        if (p) *p = 0;
        return url;
}

char* remove_urlslash(char* url)
{
        if (*url == 0) return url;
        int len = strlen(url);
        if (*(url+len-1) == '/' || *(url+len-1) == '\\')
                *(url+len-1) = 0;
        return url;
}

char* remove_urlfragment(char* url)
{
        char* p = strchr(url, '#');
        if (p) *p = 0;
        return url;
}

char* get_filename(const char* path, char* filename)
{
        char* p = strrchr(path, '\\');
        if (!p) p = strrchr(path, '/');
        if (!p) strcpy(filename, path);
        else strcpy(filename, p+1);
        return filename;
}

void center_window (HWND hwnd, HWND owner)
{
        RECT rt, par_rt;
        int h, w, par_h, par_w;

        GetWindowRect(hwnd, &rt);
        GetWindowRect(owner, &par_rt);

        w = rt.right - rt.left;
        h = rt.bottom - rt.top;
        par_w = par_rt.right - par_rt.left;
        par_h = par_rt.bottom - par_rt.top;

        int x = par_rt.left + (par_w - w) / 2;
        int y = par_rt.top + (par_h - h) / 2;
        if (x < 0) x = 0;
        if (y < 0) y = 0;

        SetWindowPos(hwnd, 0, x, y, w, h, 0);
}

void goto_url (const char* url)
{
        HKEY root, sub;
        RegOpenKey(HKEY_CLASSES_ROOT, NULL, &root);
        RegOpenKeyEx(root, "htmlfile\\shell\\open\\command", 0, KEY_ALL_ACCESS, &sub);

        DWORD type;
        unsigned char name [MAX_PATH], value [MAX_PATH];
        DWORD cbName = MAX_PATH, cbValue = MAX_PATH;
        RegEnumValue(sub, 0, (char*)name, &cbName, NULL, &type, value, &cbValue);

        char command [MAX_URL + MAX_PATH];
        strcpy(command, (char*)value);
        strcat(command, url);
        WinExec(command, SW_SHOW);

        RegCloseKey(sub);
        RegCloseKey(root);
}

int calc_explorationDepth()
{
        for (int d=0; d<g_maxDepth; d++)
        {
                if (g_qAvailableA[d]->get_surplus() != 0) return d;
                if (g_qAvailableP[d]->get_surplus() != 0) return d;
        }
        return d;
}

int get_qFailedNum()
{
        unsigned int cFailed = 0;
        for (int i=0; i<=g_maxDepth; i++) {
                cFailed += g_qFailedA->get_surplus();
                cFailed += g_qFailedP->get_surplus();
        }
        return cFailed;
}

int get_qAvailableNum()
{
        unsigned int cAvailable = 0;
        for (int i=0; i<=g_maxDepth; i++) {
                cAvailable += g_qAvailableA->get_surplus();
                cAvailable += g_qAvailableP->get_surplus();
        }
        return cAvailable;
}

int get_qProcessedPicNum()
{
        unsigned int cProcessedPic = 0;
        for (int i=0; i<=g_maxDepth; i++)
                cProcessedPic += g_qProcessedP->get_surplus();
        return cProcessedPic;
}

void save_lvcwConfig()
{
        char path [MAX_PATH] = {0};
        GetModuleFileName(g_hInst, path, sizeof(path));
        PathRemoveFileSpec(path);
        PathCombine(path, path, "PicsGet.ini");

        char lvcwDatetime [20] = {0};
        char lvcwAddress [20] = {0};
        char lvcwRemark [20] = {0};

        itoa (g_lvcwDatetime, lvcwDatetime, 10);
        itoa (g_lvcwAddress, lvcwAddress, 10);
        itoa (g_lvcwRemark, lvcwRemark, 10);

        WritePrivateProfileString("column width", "datetime", lvcwDatetime, path);
        WritePrivateProfileString("column width", "address", lvcwAddress, path);
        WritePrivateProfileString("column width", "remark", lvcwRemark, path);
}

void load_lvcwConfig()
{
        char path [MAX_PATH] = {0};
        GetModuleFileName(g_hInst, path, sizeof(path));
        PathRemoveFileSpec(path);
        PathCombine(path, path, "PicsGet.ini");

        g_lvcwDatetime = GetPrivateProfileInt("column width", "datetime", 100, path);
        g_lvcwAddress = GetPrivateProfileInt("column width", "address", 500, path);
        g_lvcwRemark = GetPrivateProfileInt("column width", "remark", 200, path);

        if (g_lvcwDatetime > 1200 || g_lvcwDatetime < 50) g_lvcwDatetime = 100;
        if (g_lvcwAddress > 1200 || g_lvcwAddress < 50) g_lvcwAddress = 100;
        if (g_lvcwRemark > 1200 || g_lvcwRemark < 50) g_lvcwRemark = 100;
}

char* get_prfFilename(const char* prf, char* filename)
{
        get_filename(prf, filename);
        PathRemoveExtension(filename);
        return filename;
}

char* get_prfDirectory(const char* prf, char* directory)
{
        strcpy(directory, prf);
        PathRemoveFileSpec(directory);
        return directory;
}

char* get_prfSysdir(const char* prf, char* sysdir)
{
        strcpy(sysdir, prf);
        strcat(sysdir, ".data");
        PathCombine(sysdir, sysdir, "sys");
        return sysdir;
}

char* get_prfTmpdir(const char* prf, char* tmpdir)
{
        strcpy(tmpdir, prf);
        strcat(tmpdir, ".data");
        PathCombine(tmpdir, tmpdir, "tmp");
        return tmpdir;
}

char* get_prfPicdir(const char* prf, char* picdir)
{
        strcpy(picdir, prf);
        strcat(picdir, ".data");
        PathCombine(picdir, picdir, "pic");
        return picdir;
}

extern time_t g_startTime;
extern time_t g_endTime;

char* get_elapsedTime(char* elapsed)
{
        time(&g_endTime);
        int sub = g_endTime - g_startTime;
        int h = sub / 3600;
        int m = (sub - h*3600) / 60;
        int s = sub - h*3600 - m*60;
        h = h < 24 ? h : 24;
        sprintf(elapsed, "%.2d:%.2d:%.2d", h, m, s);
        return elapsed;
}

void create_toolbar()
{
        TBADDBITMAP bmps[7] = {
                {g_hInst,IDB_new},
                {g_hInst,IDB_open},
                {g_hInst,IDB_run},
                {g_hInst,IDB_stop},
                {g_hInst,IDB_picsFolder} };
        TBBUTTON btns [7] = {
                {0,IDM_new,TBSTATE_ENABLED,TBSTYLE_BUTTON,0,IDS_new},       
                {1,IDM_open,TBSTATE_ENABLED,TBSTYLE_BUTTON,0,IDS_open}, {0,0,TBSTATE_ENABLED,TBSTYLE_SEP,0,0},
                {2,IDM_run,TBSTATE_ENABLED,TBSTYLE_BUTTON,0,IDS_run},
                {3,IDM_stop,TBSTATE_ENABLED,TBSTYLE_BUTTON,0,IDS_stop}, {0,0,TBSTATE_ENABLED,TBSTYLE_SEP,0,0},
                {4,IDM_picsFolder,TBSTATE_ENABLED,TBSTYLE_BUTTON,0,IDS_picsFolder} };

        g_hToolbar = CreateWindow(
                TOOLBARCLASSNAME, NULL, WS_CHILD | TBSTYLE_TOOLTIPS, 0, 0, 0, 0, g_hMain, 0, g_hInst, NULL);

        SendMessage(g_hToolbar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
        SendMessage(g_hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(16,16));
        SendMessage(g_hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(16,16));
        for (int i=0; i<7; i++)
                SendMessage(g_hToolbar, TB_ADDBITMAP, 1, (LPARAM) &bmps);
        SendMessage(g_hToolbar, TB_ADDBUTTONS, 7, (LPARAM) &btns);

        SendMessage(g_hToolbar, TB_AUTOSIZE, 0, 0);
        ShowWindow(g_hToolbar, SW_SHOW);
}

void update_toolbarState()
{
        SendMessage(g_hToolbar,TB_SETSTATE,IDM_new,(LPARAM)MAKELONG((g_connectPool ? 0 : TBSTATE_ENABLED), 0));
        SendMessage(g_hToolbar,TB_SETSTATE,IDM_open,(LPARAM)MAKELONG((g_connectPool ? 0 : TBSTATE_ENABLED), 0));
        SendMessage(g_hToolbar,TB_SETSTATE,IDM_stop,(LPARAM)MAKELONG((g_connectPool && (!is_mtStopping()) ? TBSTATE_ENABLED : 0), 0));
        SendMessage(g_hToolbar,TB_SETSTATE,IDM_picsFolder,(LPARAM)MAKELONG((g_depthNow ? TBSTATE_ENABLED : 0), 0));
        BOOL b = (!g_connectPool) && g_depthNow && get_qAvailableNum() >= 1;
        SendMessage(g_hToolbar,TB_SETSTATE,IDM_run,(LPARAM)MAKELONG((b ? TBSTATE_ENABLED : 0), 0));
}

bool open_lastfMenuId(WORD dwId)
{
        if (dwId < IDM_LASTFILE || dwId >= IDM_LASTFILE+5)
                return false;
       
        int index = 0;
        list<string>::iterator pos = g_listLastFile.begin();
        while (pos != g_listLastFile.end())
        {
                if (index == dwId-IDM_LASTFILE) {
                        if (!PathFileExists((*pos).c_str())) {
                                del_lastf((*pos).c_str());
                                update_lastfMenu();
                                goto END;
                        }
                        doClose();
                        doOpen((*pos).c_st

TurlQueue::TurlQueue(const char* path)
{
        strcpy(m_path, path);
        m_cw = m_cr = 0;
        m_pos = 0;

        m_hMutex = CreateMutex (NULL, FALSE, NULL);

        FILE* f = fopen(path, "rb");
        if (f) {
                fread(&m_pos, sizeof(m_pos), 1, f);
                fclose(f);
        }
}

TurlQueue::~TurlQueue()
{
        flush();
        CloseHandle(m_hMutex);
}

void TurlQueue::add(const char* url, const char* remark)
{
        WaitForSingleObject(m_hMutex, INFINITE);

        download_obj_t obj = {0};

        get_datetime(obj.datetime);
        strcpy(obj.url, url);
        strcpy(obj.remark, remark);

        m_w_list.push_back(obj);
        m_cw++;

        if (m_cw > MAX_W_CACHE)
        {
                FILE* f = NULL;
                if (PathFileExists(m_path)) f = fopen(m_path, "a+b");
                else {
                        f = fopen(m_path, "a+b");
                        fwrite(&m_pos, sizeof(m_pos), 1, f);
                }

                list<download_obj_t>::iterator pos = m_w_list.begin();
                while (pos != m_w_list.end()) {
                        fwrite(&(*pos), sizeof(download_obj_t), 1, f);
                        pos++;
                }
                fflush(f);
                fclose(f);
                m_w_list.clear();
                m_cw = 0;
        }

        ReleaseMutex(m_hMutex);
}

bool TurlQueue::pop(char* datetime, char* url, char* remark)
{
        WaitForSingleObject(m_hMutex, INFINITE);

        if (m_cr == 0)
        {
                FILE* f = NULL;

                if (m_cw != 0)
                {
                        if (PathFileExists(m_path)) f = fopen(m_path, "a+b");
                        else {
                                f = fopen(m_path, "a+b");
                                fwrite(&m_pos, sizeof(m_pos), 1, f);
                        }

                        list<download_obj_t>::iterator pos = m_w_list.begin();
                        while (pos != m_w_list.end()) {
                                fwrite(&(*pos), sizeof(download_obj_t), 1, f);
                                pos++;
                        }
                        fflush(f);
                        fclose(f);
                        m_cw = 0;
                        m_w_list.clear();
                }

                f = fopen(m_path, "rb");
                if (f)
                {
                        fseek(f, sizeof(download_obj_t)*m_pos + sizeof(m_pos), SEEK_SET);
                        while (1) {
                                download_obj_t obj;
                                if (fread(&obj, sizeof(obj), 1, f) != 1) break;
                                m_r_list.push_back(obj);
                                m_cr++;       
                                m_pos++;
                                if (m_cr > MAX_R_CACHE) break;
                        }
                        fclose(f);
                }

                if (m_cr != 0) {
                        f = fopen(m_path, "r+b");
                        fwrite(&m_pos, sizeof(m_pos), 1, f);
                        fclose(f);
                }
        }

        if (m_cr == 0) {
                ReleaseMutex(m_hMutex);
                return false;
        }

        list<download_obj_t>::iterator first = m_r_list.begin();

        strcpy(datetime, (*first).datetime);
        strcpy(url, (*first).url);
        strcpy(remark, (*first).remark);

        m_r_list.pop_front();
        m_cr--;
        ReleaseMutex(m_hMutex);
        return true;
}

void TurlQueue::flush()
{
        WaitForSingleObject(m_hMutex, INFINITE);

        if (m_cr != 0)
        {
                list<download_obj_t>::iterator pos = m_r_list.begin();
                while (pos != m_r_list.end()) {
                        m_w_list.push_back(*pos);
                        m_cw++;
                        pos++;
                }
                m_cr = 0;
                m_r_list.clear();
        }

        if (m_cw != 0)
        {
                FILE* f = NULL;
                if (PathFileExists(m_path)) f = fopen(m_path, "a+b");
                else {
                        f = fopen(m_path, "a+b");
                        fwrite(&m_pos, sizeof(m_pos), 1, f);
                }

                list<download_obj_t>::iterator pos = m_w_list.begin();
                while (pos != m_w_list.end()) {
                        fwrite(&(*pos), sizeof(download_obj_t), 1, f);
                        pos++;
                }
                fflush(f);
                fclose(f);
                m_cw = 0;
                m_w_list.clear();
        }

        ReleaseMutex(m_hMutex);
}

unsigned int TurlQueue::get_surplus()
{
        WaitForSingleObject(m_hMutex, INFINITE);

        int surplus = 0;
        FILE* f = fopen(m_path, "rb");
        if (f) {
                surplus = (_filelength(_fileno(f))-sizeof(m_pos)) / sizeof(download_obj_t) - m_pos;
                fclose(f);
        }

        surplus += m_cr;
        surplus += m_cw;

        ReleaseMutex(m_hMutex);

        return surplus;
}