win32.c

系统任务管理器

            gkrellm_fs_assign_fsusage_data(fs, totalClusters * secPerCluster, freeClusters * secPerCluster, freeClusters * secPerCluster, bytesPerSector);
        }
    }

}

void gkrellm_sys_fs_get_mounts_list(void)
{
    char buf[1024];
    char* drive;

    GetLogicalDriveStrings(1024, buf);
    for (drive = buf; *drive != 0; drive += lstrlen(drive) + 1) {
        // dir, dev, type
        if (strcmp("A:\\", drive) != 0 && strcmp("a:\\", drive) != 0 && strcmp("B:\\", drive) != 0 && strcmp("b:\\", drive) != 0) {
    	    gkrellm_fs_add_to_mounts_list(drive, drive, "");
        }
    }    
}

void gkrellm_sys_fs_get_fstab_list(void)
{
    char buf[1024];
    char* drive;

    GetLogicalDriveStrings(1024, buf);
    for (drive = buf; *drive != 0; drive += lstrlen(drive) + 1) {
        // dir, dev, type, opt
        if (strcmp("A:\\", drive) != 0 && strcmp("a:\\", drive) != 0 && strcmp("B:\\", drive) != 0 && strcmp("b:\\", drive) != 0) {
            if (_GK.debug_level & DEBUG_SYSDEP)
                printf("Adding fstab %s\n", drive);
            gkrellm_fs_add_to_fstab_list(drive, drive, "", "");
        }
    }    
}

/* ================================================ */
/* INET monitor interfaces */
/* ===================================================================== */

gboolean gkrellm_sys_inet_init(void)
{
    //return TRUE;
    return FALSE;
}

void gkrellm_sys_inet_read_tcp_data(void)
{
//    FILE		*f;
//	ActiveTCP	tcp;
//	gchar		buf[512];
//	gint		tcp_status;
//	gulong		addr;

    //what address should this be?
    // this is an in_addr
    // what ports?
//    tcp.remote_addr.s_addr = inet_addr("127.0.0.1");
//    tcp.family = AF_INET;
//    tcp.remote_port = 80;
//    tcp.local_port = 80;

//    gkrellm_inet_log_tcp_port_data(&tcp);

/*	if ((f = fopen(PROC_NET_TCP_FILE, "r")) != NULL)
		{
		fgets(buf, sizeof(buf), f);		

		while (fgets(buf, sizeof(buf), f))
			{
			sscanf(buf, "%*d: %*x:%x %lx:%x %x", &tcp.local_port,
						&addr, &tcp.remote_port, &tcp_status);
			tcp.remote_addr.s_addr = (uint32_t) addr;
			tcp.family = AF_INET;
			if (tcp_status != TCP_ALIVE)
				continue;
			gkrellm_inet_log_tcp_port_data(&tcp);
			}
		fclose(f);
		}
*/
}



/* ===================================================================== */
/* Uptime monitor interface */
/* ===================================================================== */

time_t gkrellm_sys_uptime_read_uptime(void)
{
#if defined(USE_PDH)
    DWORD type;
    PDH_FMT_COUNTERVALUE value;
#endif
    long l = 0;

    win32_read_proc_stat();

#if defined(USE_PDH)
    if (winVer > 0 && query != 0) {
        status = PdhGetFormattedCounterValue(uptimeCounter, PDH_FMT_LONG, &type, &value);
        l = value.longValue;
    }
#else
    l = GetTickCount() / 1000;
#endif

    return (time_t) l;
    }

gboolean gkrellm_sys_uptime_init(void)
{
#if defined(USE_PDH)
    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Initializing uptime monitor.\n");

    if (winVer > 0 && query != 0) {
        status = PdhAddCounter(query, perfKeys[4], 0, &uptimeCounter);
    }
#endif

    return TRUE;
    }

/* ===================================================================== */
/* hostname interface */
/* ===================================================================== */

gchar *gkrellm_sys_get_host_name(void)
{
	static gboolean	have_it = FALSE;
    char buf2[128];
    int err;

    if (!have_it) {
        err = gethostname(buf2, 128);

        if (err != 0) {
            hostname = g_strdup("Unknown");
        }
        else {
            hostname = g_strdup(buf2);
        }

        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Retrieving host name.\n");

        have_it = TRUE;
    }

	return hostname;
}

/* ===================================================================== */
/* System name interface */
/* ===================================================================== */

gchar *gkrellm_sys_get_system_name(void)
{
	static gboolean	have_it = FALSE;
    char osName[255];
    char build[255];

    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Retrieving system name.\n");

    if (!have_it) {
        strcpy(osName, "Unknown");
        strcpy(build, "");

        if (info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
            if (info.dwMinorVersion == 0) {
                strcpy(osName, "Win 95");
            }
            if (info.dwMinorVersion == 10) {
                strcpy(osName, "Win 98");
            }
            if (info.dwMinorVersion == 90) {
                strcpy(osName, "Win Me");
            }
    //        ss << " (" << LOWORD(build) << ")";
    //        if (CSDVersion.size() > 0) {
    //            ss << CSDVersion[0];
    //        }
        }
        else {
            if (info.dwPlatformId == VER_PLATFORM_WIN32_NT) {
                if (info.dwMinorVersion == 0) {
                    if (info.dwMajorVersion == 5) {
                        strcpy(osName, "Win 2000");
                    }
                    if (info.dwMajorVersion == 4) {
                        strcpy(osName, "Win NT 4.0");
                    }
                }
                if (info.dwMinorVersion == 51) {
                    strcpy(osName, "Win NT 3.51");
                }
                if (info.dwMinorVersion == 1) {
                    strcpy(osName, "Win XP");
                }
    //            ss << " (" << build << ")";
            }
        }

        sname = g_strdup(osName);
        have_it = TRUE;
    	//sname = g_strdup_printf("%s %s", osName, "");
    }


    return sname;
}

/* ===================================================================== */
/* Misc functions */
/* ===================================================================== */

void readPerfKeyFile(void)
{
    FILE* fp;
    gchar *fileName;
    TCHAR buf[1024];
    TCHAR key[1024];
    TCHAR* s;
    int pos;

    // load defaults in case file is not there or missing entries
    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Beginning read of perfkey.dat\n");
#if defined(USE_PDH)
    // \\Processor(0)
    placePerfKey("processor_time", _T(")\\% Processor Time"));
    placePerfKey("privileged_time", _T(")\\% Privileged Time"));
    placePerfKey("processes", _T("\\System\\Processes"));
    placePerfKey("forks", _T("\\System\\Threads"));
    placePerfKey("uptime", _T("\\System\\System Up Time"));
    placePerfKey("netpart1", _T("\\Network Interface("));
    placePerfKey("netreceive", _T(")\\Bytes Received/sec"));
    placePerfKey("netsend", _T(")\\Bytes Sent/sec"));
    placePerfKey("diskpart1", _T("\\PhysicalDisk("));
    placePerfKey("diskread", _T(")\\Disk Read Bytes/sec"));
    placePerfKey("diskwrite", _T(")\\Disk Write Bytes/sec"));
    placePerfKey("processor_start", _T("\\Processor("));
#else
    placePerfKey("cpuusage", _T("KERNEL\\CPUUsage"));
    placePerfKey("threads", _T("KERNEL\\Threads"));
    placePerfKey("breads", _T("VFAT\\BReadsSec"));
    placePerfKey("bwrites", _T("VFAT\\BWritesSec"));
    placePerfKey("bnetwork", _T("Network Monitor\\0000 - Ethernet bytes/second"));
    placePerfKey("netname", _T("Ether"));
#endif

    // now try to read translated keys from file
    fileName = g_strdup_printf("%s\\%s\\perfkey.dat", gkrellm_homedir(), GKRELLM_DIR);
    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Looking for perfkey.dat at %s\n", fileName);

    fp = fopen(fileName, "r");
    if (fp) {
		while ((fgets(buf, sizeof(buf), fp)) != NULL) {
			if ((s = _tcschr(buf, _T('\n'))) != NULL)
				*s = _T('\0');

            if (_tcsclen(buf) > 0 && buf[0] != _T(';')) {
                if ((s = _tcschr(buf, _T(' '))) != NULL) {
                    if (_tcsclen(s) > 0) {
                        ++s;
                        pos = s - buf - 1;

                        if (pos > 0) {
                            _tcsncpy(key, buf, pos);
                            key[pos] = _T('\0');

                            placePerfKey(key, s);
                        }
                    }
                }
            }
        }
        fclose(fp);
    }
    else {
        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Opening perfkey.dat failed, using English defaults.\n");
    }

    g_free(fileName);
}

void placePerfKey(const TCHAR* key, const TCHAR* item)
{
    int place = -1;
    int size;

#if defined(USE_PDH)
    if (_tcscmp(key, _T("processor_time")) == 0)
        place = 0;
    if (_tcscmp(key, _T("privileged_time")) == 0)
        place = 1;
    if (_tcscmp(key, _T("processes")) == 0)
        place = 2;
    if (_tcscmp(key, _T("forks")) == 0)
        place = 3;
    if (_tcscmp(key, _T("uptime")) == 0)
        place = 4;
    if (_tcscmp(key, _T("netpart1")) == 0)
        place = 5;
    if (_tcscmp(key, _T("netreceive")) == 0)
        place = 6;
    if (_tcscmp(key, _T("netsend")) == 0)
        place = 7;
    if (_tcscmp(key, _T("diskpart1")) == 0)
        place = 8;
    if (_tcscmp(key, _T("diskread")) == 0)
        place = 9;
    if (_tcscmp(key, _T("diskwrite")) == 0)
        place = 10;
    if (_tcscmp(key, _T("processor_start")) == 0)
        place = 11;
#else
    if (_tcscmp(key, _T("cpuusage")) == 0)
        place = 0;
    if (_tcscmp(key, _T("threads")) == 0)
        place = 1;
    if (_tcscmp(key, _T("breads")) == 0)
        place = 2;
    if (_tcscmp(key, _T("bwrites")) == 0)
        place = 3;
    if (_tcscmp(key, _T("bnetwork")) == 0)
        place = 4;
    if (_tcscmp(key, _T("netname")) == 0)
        place = 5;
#endif

    if (_GK.debug_level & DEBUG_SYSDEP)
        printf("Found place %i for key %s\n", place, key);

    if (place != -1 && place < numPerfKeys) {
        free(perfKeys[place]);
        size = _tcsclen(item);
        perfKeys[place] = malloc(sizeof(TCHAR) * size + 1);
        _tcscpy(perfKeys[place], item);
        
        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Putting item %s in key %s\n", item, key);
    }
    else {
        if (_GK.debug_level & DEBUG_SYSDEP)
            printf("Invalid placement for key %s and item %s\n", key, item);
    }
}

int getuid()
{
    // gets user id - doesn't exist for Windows
    return 0;
}

void fcntl(int fd, int cmd, ...)
{
    // Windows can't lock files that I know of
}

void fchmod(int fd, mode_t mode)
{
    // no way to set permissions on Windows
}

//int getpid()
//{
//    return 0;
//}

void win32_init_callbacks(void)
{
#if defined(WIN32_CLIENT)
      // Data structure allocation
    plugin_callbacks.gkrellm_chart_new0 = gkrellm_chart_new0;
    plugin_callbacks.gkrellm_chartconfig_new0 = gkrellm_chartconfig_new0;
    plugin_callbacks.gkrellm_panel_new0 = gkrellm_panel_new0;
    plugin_callbacks.gkrellm_krell_new0 = gkrellm_krell_new0;
    plugin_callbacks.gkrellm_decal_new0 = gkrellm_decal_new0;
    plugin_callbacks.gkrellm_label_new0 = gkrellm_label_new0;
    plugin_callbacks.gkrellm_style_new0 = gkrellm_style_new0;
    plugin_callbacks.gkrellm_copy_style = gkrellm_copy_style;
    plugin_callbacks.gkrellm_copy_style_values = gkrellm_copy_style_values;
    plugin_callbacks.gkrellm_textstyle_new0 = gkrellm_textstyle_new0;
    plugin_callbacks.gkrellm_copy_textstyle = gkrellm_copy_textstyle;

    // Chart functions
    plugin_callbacks.gkrellm_chart_create = gkrellm_chart_create;
    plugin_callbacks.gkrellm_chart_destroy = gkrellm_chart_destroy;
    plugin_callbacks.gkrellm_chart_hide = gkrellm_chart_hide;
    plugin_callbacks.gkrellm_chart_show = gkrellm_chart_show;
    plugin_callbacks.gkrellm_chart_enable_visibility = gkrellm_chart_enable_visibility;
    plugin_callbacks.gkrellm_is_chart_visible = gkrellm_is_chart_visible;
    plugin_callbacks.gkrellm_set_draw_chart_function = gkrellm_set_draw_chart_function;
    plugin_callbacks.gkrellm_draw_chart_to_screen = gkrellm_draw_chart_to_screen;
    plugin_callbacks.gkrellm_draw_chart_label = gkrellm_draw_chart_label;
    plugin_callbacks.gkrellm_draw_chart_text = gkrellm_draw_chart_text;
    plugin_callbacks.gkrellm_reset_chart = gkrellm_reset_chart;
    plugin_callbacks.gkrellm_reset_and_draw_chart = gkrellm_reset_and_draw_chart;
    plugin_callbacks.gkrellm_refresh_chart = gkrellm_refresh_chart;
    plugin_callbacks.gkrellm_rescale_chart = gkrellm_rescale_chart;
    plugin_callbacks.gkrellm_clear_chart = gkrellm_clear_chart;
    plugin_callbacks.gkrellm_clear_chart_pixmap = gkrellm_clear_chart_pixmap;
    plugin_callbacks.gkrellm_clean_bg_src_pixmap = gkrellm_clean_bg_src_pixmap;
    plugin_callbacks.gkrellm_draw_chart_grid_line = gkrellm_draw_chart_grid_line;
    plugin_callbacks.gkrellm_chart_bg_piximage_override = gkrellm_chart_bg_piximage_override;
    plugin_callbacks.gkrellm_chart_width = gkrellm_chart_width;
    plugin_callbacks.gkrellm_set_chart_height_default = gkrellm_set_chart_height_default;
    plugin_callbacks.gkrellm_set_chart_height = gkrellm_set_chart_height;
    plugin_callbacks.gkrellm_get_chart_scalemax = gkrellm_get_chart_scalemax;
    plugin_callbacks.gkrellm_render_data_pixmap = gkrellm_render_data_pixmap;
    plugin_callbacks.gkrellm_render_data_grid_pixmap = gkrellm_render_data_grid_pixmap;

      // ChartData functions
    plugin_callbacks.gkrellm_add_chartdata = gkrellm_add_chartdata;
    plugin_callbacks.gkrellm_add_default_chartdata = gkrellm_add_default_chartdata;
    plugin_callbacks.gkrellm_alloc_chartdata = gkrellm_alloc_chartdata;
    plugin_callbacks.gkrellm_store_chartdata = gkrellm_store_chartdata;
    plugin_callbacks.gkrellm_draw_chartdata = gkrellm_draw_chartdata;
    plugin_callbacks.gkrellm_monotonic_chartdata = gkrellm_monotonic_chartdata;
    plugin_callbacks.gkrellm_get_chartdata_hide = gkrellm_get_chartdata_hide;
    plugin_callbacks.gkrellm_get_current_chartdata = gkrellm_get_current_chartdata;
    plugin_callbacks