tables.c

来自「db.* (pronounced dee-be star) is an adva」· C语言 代码 · 共 708 行 · 第 1/2 页

    memcpy(user_o, bm, max_filebmbytes);
    bm += max_filebmbytes;
    memcpy(user_l, bm, max_filebmbytes);
    bm += max_filebmbytes;
    memcpy(user_r, bm, max_filebmbytes);
    bm += max_filebmbytes;

    ftp = (LR_FILEINFO *) bm;

    for (i = 0; i < cur_sizes.lm_numfiles; i++)
    {
        vtstrcpy(files[i].name, ftp->fi_name);
        files[i].lockstat = ftp->fi_lockstat;
        files[i].qentry = ftp->fi_queue;
        ftp++;
    }

    if (cur_sizes.lm_maxqueue > 0)
        memcpy(queue, ftp, sizeof(QUEUETAB) * cur_sizes.lm_maxqueue);

    psp_lmcFree(rup);
}

void get_file_info(int file)
{
    int          i, stat;
    DB_BYTE     *bm;
    DB_TCHAR    *pusername;
    LR_FILEINFO *rfp;

    if (get_general_status())
        return;

    ssp->type_of_status = ST_FILEINFO;
    ssp->number = file;
    memcpy(&ssp->tabsize, &cur_sizes, sizeof(TABSIZE));

    stat = psp_lmcTrans(L_STATUS, ssp, sizeof(LM_STATUS), (void **) &rfp,
            NULL, NULL, lmc);
    if (stat != PSP_OKAY)
        return;

    vtstrcpy(filename, rfp->fi_name);
    files[file].lockstat = rfp->fi_lockstat;
    files[file].qentry = rfp->fi_queue;

    bm = (DB_BYTE *) (rfp + 1);

    memcpy(file_o, bm, max_userbmbytes);
    bm += max_userbmbytes;

    memcpy(file_l, bm, max_userbmbytes);
    bm += max_userbmbytes;

    for (i = 0, pusername = bm; i < cur_sizes.lm_numusers; i++, pusername += 16)
        vtstrcpy(users[i].name, pusername);

    if (cur_sizes.lm_maxqueue > 0)
        memcpy(queue, pusername, sizeof(QUEUETAB) * cur_sizes.lm_maxqueue);

    psp_lmcFree(rfp);
}

long GetNumQItems()
{
    int i, q_ent;
    long total = 0;

    for (i = 0, total = 0; i < cur_sizes.lm_numfiles; i++)
    {
        if (files[i].name[0])
        {
            q_ent = files[i].qentry;
            while (q_ent != -1)
            {
                total++;
                q_ent = queue[q_ent].q_next;
            }
        }
    }
    return total;
}

long GetMsgsReceived()
{
    return msgsr;
}

long GetMsgsSent()
{
    return msgss;
}

long GetLocksGranted()
{
    return granted;
}

long GetLocksRejected()
{
    return rejected;
}

long GetLocksTimedOut()
{
    return timedout;
}

long GetTotalLocks()
{
    return granted + rejected + timedout;
}

long GetLocksFreed()
{
    return freed;
}

int GetNumUsers()
{
    return cur_sizes.lm_numusers;
}

int IsUserActive(int user)
{
    if (users[user].status == U_DEAD || users[user].status == U_EMPTY)
        return 0;
    else
        return 1;
}

DB_TCHAR *GetUserId(int user)
{
    return (users[user].status ? users[user].name : DB_TEXT(""));
}

DB_TCHAR *GetUserTAF(int user)
{
    return (users[user].status ? users[user].taffile : DB_TEXT(""));
}

int GetUserPending(int user)
{
    return (users[user].status ? users[user].pending : 0);
}

int GetUserTimeOut(int user)
{
    return (users[user].status ? users[user].timeout : 0);
}

int GetUserTimer(int user)
{
    return (users[user].status ? users[user].timer : 0);
}

DB_TCHAR *GetUserStatus(int user)
{
    return (status[users[user].status]);
}

DB_TCHAR *GetUserRecover(int user)
{
    static DB_TCHAR temp_yes[4] = DB_TEXT("Yes");
    static DB_TCHAR temp_no[4]  = DB_TEXT("No");

    return (users[user].status ? ((users[user].recover == -1) ? temp_no : temp_yes) : DB_TEXT(""));
}

DB_TCHAR *GetUserLogFile(int user)
{
    return (users[user].status ? users[user].logfile : DB_TEXT(""));
}

int GetNumFiles()
{
    return cur_sizes.lm_numfiles;
}

int IsFileActive(int file)
{
    return (files[file].name[0] != 0);
}

DB_TCHAR *GetFileName(int file, short path_flag)
{
    if (path_flag)
        return filename;
    else
        return files[file].name;
}

char GetLockStat(int file)
{
    return (char) (files[file].name[0] ? files[file].lockstat : ' ');
}

int GetNumLocks(int file)
{
    return (files[file].name[0] ? files[file].numlocks : 0);
}

DB_TCHAR *GetUserWLock(int file)
{
    static DB_TCHAR temp[20];

    temp[0] = 0;
    if (files[file].name[0] && files[file].lockstat != (int) 'f')
        vtstrcpy(temp, users[files[file].user_with_lock].name);
    return temp;
}

DB_TCHAR *GetPendLocks(int file)
{
    int q_ent;
    static DB_TCHAR temp[FILENMLEN];
    DB_TCHAR *p = temp;
    int left = FILENMLEN, plen;

    *p = 0;
    if (files[file].name[0])
    {
        if (files[file].lockstat == (int) 'f')
            return (temp);
        else
        {
            q_ent = files[file].qentry;
            while (q_ent != -1)
            {
                vtstrncpy(p, users[queue[q_ent].q_user].name, left);
                p[left-1] = 0;
                plen = vtstrlen(p);
                left -= plen; p += plen;
                if (left <= 1)
                    break;

                vtstrncpy(p, DB_TEXT("  "), left);
                p[left-1] = 0;
                plen = vtstrlen(p);
                left -= plen; p += plen;
                if (left <= 1)
                    break;
                q_ent = queue[q_ent].q_next;
            }
        }
    }
    return (temp);
}

int UserHasOpen(int user, int file)
{
    return (is_bit_set(user_o, file));
}

int UserHasLock(int user, int file)
{
    return (is_bit_set(user_l, file));
}

int UserHasReq(int user, int file)
{
    return (is_bit_set(user_r, file));
}

char UserWaitingLock(int user, int file)
{
    int q_entry;

    q_entry = files[file].qentry;
    while (q_entry != -1)
    {
        if (queue[q_entry].q_user == user)
            return (char) (queue[q_entry].q_locktype);
        q_entry = queue[q_entry].q_next;
    }
    return ' ';
}

int UserNumOpen(int user)
{
    return (count_bits(user_o, cur_sizes.lm_numfiles));
}

int UserNumLock(int user)
{
    return (count_bits(user_l, cur_sizes.lm_numfiles));
}

int UserNumReq(int user)
{
    return (count_bits(user_r, cur_sizes.lm_numfiles));
}

int FileOpenByUser(int file, int user)
{
    return (is_bit_set(file_o, user));
}

int FileLockedByUser(int file, int user)
{
    return (is_bit_set(file_l, user));
}

char FileRequestedByUser(int file, int user)
{
    int qent = files[file].qentry;

    while (qent != -1)
    {
        if (queue[qent].q_user == user)
            return (char) queue[qent].q_locktype;
        qent = queue[qent].q_next;
    }
    return ' ';
}

int FileNumOpen(int file)
{
    return (count_bits(file_o, cur_sizes.lm_numusers));
}

int FileNumLock(int file)
{
    return (count_bits(file_l, cur_sizes.lm_numusers));
}

int FileNumReq(int file)
{
    int total = 0;
    int qent = files[file].qentry;

    while (qent != -1)
    {
        total++;
        qent = queue[qent].q_next;
    }
    return total;
}

int count_bits(DB_BYTE *map, int max)
{
    int i, temp;

    for (i = 0, temp = 0; i < max; i++)
    {
        if (is_bit_set(map, i))
            temp++;
    }

    return temp;
}