inittab.c

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

				else
					atow(q, p, flen);
				
				psp_freeMemory(q, 0);
			}
#endif
			if (stat == S_OKAY)
			{
				curr_dbt->Objnames = p;
				getnames(task->record_names, &p, curr_dbt->rt_offset,
					(short) (curr_dbt->rt_offset + curr_dbt->Size_rt));
				getnames(task->field_names, &p, curr_dbt->fd_offset,
					(short) (curr_dbt->fd_offset + curr_dbt->Size_fd));
				getnames(task->set_names, &p, curr_dbt->st_offset,
					(short) (curr_dbt->st_offset + curr_dbt->Size_st));
				flen -= p - curr_dbt->Objnames;
			}
		}
		else
		{
			DB_TCHAR *tmp = p;
			
			skipnames(&p, (short) (curr_dbt->Size_rt + curr_dbt->Size_fd +
				curr_dbt->Size_st));
			flen -= p - tmp;
		}
		
		if (stat == S_OKAY)
		{
			if (flen == 16)
			{
				if (!sg)
					stat = S_INVENCRYPT;
				else if (!(*sg->chk)(sg->data, p))
					stat = S_INVENCRYPT;
			}
			else if (sg)
				stat = S_INVENCRYPT;
		}
	}
	
	psp_fileClose(dbf);
	if (stat != S_OKAY)
		return dberr(stat);

	return S_OKAY;
}

static int get_sc_dict_sizes(int dbt_lc, struct DICT_SIZE * dict_size, const DB_SCHEMA * sc, DB_TASK * task)
{
	DB_ENTRY          * curr_dbt = task->curr_db_table + dbt_lc;

	curr_dbt->db_ver     = sc->sc_version;
	dict_size->Page_size = sc->sc_page_size;
    dict_size->Size_ft   = sc->sc_nfiles;
    dict_size->Size_rt   = sc->sc_nrecords;
    dict_size->Size_fd   = sc->sc_nfields;
    dict_size->Size_st   = sc->sc_nsets;
    dict_size->Size_mt   = sc->sc_nmembers;
    dict_size->Size_srt  = sc->sc_nsorts;
    dict_size->Size_kt   = sc->sc_nkeys;
	return task->db_status;
}

static int load_schema(int dbt_lc, const SG *sg, const DB_SCHEMA * sc, DB_TASK *task)
{
	DB_ENTRY          * curr_dbt = task->curr_db_table + dbt_lc;
    int                 i, n;
	int                 nlen;
	DB_TCHAR          * p;
	FILE_ENTRY        * fptr;
	union {
		V300_FILE_ENTRY    * v300;
		V301_FILE_ENTRY    * v301;
		V500_FILE_ENTRY    * v500;
		U500_FILE_ENTRY    * u500;
	} fe;

	fe.v300 = (V300_FILE_ENTRY*)sc->sc_files;

	fptr = &task->file_table[curr_dbt->ft_offset];
	for (i = 0; i < curr_dbt->Size_ft; ++i, ++fptr)
	{
		switch (curr_dbt->db_ver)
		{
		case 300:
			atot(fe.v300->v3_ft_name, fptr->ft_name, FILENMLEN);
			fptr->ft_status  = fe.v300->v3_ft_status;
			fptr->ft_type    = fe.v300->v3_ft_type;
			fptr->ft_slots   = fe.v300->v3_ft_slots;
			fptr->ft_slsize  = fe.v300->v3_ft_slsize;
			fptr->ft_pgsize  = fe.v300->v3_ft_pgsize;
			fptr->ft_flags   = fe.v300->v3_ft_flags;
			fptr->ft_pctincrease = 0;
			fptr->ft_initial = 0;
			fptr->ft_next    = 0;
			fptr->ft_index   = -1;
			fptr->ft_lmtimestamp = 0;
			fptr->ft_cachetimestamp = 0;
			fe.v300++;
			break;
			
		case 301:
			atot(fe.v301->v3_ft_name, fptr->ft_name, FILENMLEN);
			fptr->ft_status  = fe.v301->v3_ft_status;
			fptr->ft_type    = fe.v301->v3_ft_type;
			fptr->ft_slots   = fe.v301->v3_ft_slots;
			fptr->ft_slsize  = fe.v301->v3_ft_slsize;
			fptr->ft_pgsize  = fe.v301->v3_ft_pgsize;
			fptr->ft_flags   = fe.v301->v3_ft_flags;
			fptr->ft_pctincrease = fe.v301->v3_ft_pctincrease;
			fptr->ft_initial = fe.v301->v3_ft_initial;
			fptr->ft_next    = fe.v301->v3_ft_next;
			fptr->ft_index = -1;
			fptr->ft_lmtimestamp = 0;
			fptr->ft_cachetimestamp = 0;
			fe.v301++;
			break;
			
		case 500:
			atot(fe.v500->v5_ft_name, fptr->ft_name, FILENMLEN);
			fptr->ft_status  = fe.v500->v5_ft_status;
			fptr->ft_type    = fe.v500->v5_ft_type;
			fptr->ft_slots   = fe.v500->v5_ft_slots;
			fptr->ft_slsize  = fe.v500->v5_ft_slsize;
			fptr->ft_pgsize  = fe.v500->v5_ft_pgsize;
			fptr->ft_flags   = fe.v500->v5_ft_flags;
			fptr->ft_pctincrease = fe.v500->v5_ft_pctincrease;
			fptr->ft_initial = fe.v500->v5_ft_initial;
			fptr->ft_next    = fe.v500->v5_ft_next;
			fptr->ft_index = -1;
			fptr->ft_lmtimestamp = 0;
			fptr->ft_cachetimestamp = 0;
			fe.v500++;
			break;

		case -500:
#ifdef UNICODE
			wcsncpy(fptr->ft_name, fe.u500->v5_ft_name, FILENMLEN);
#else
			wtoa(fe.u500->v5_ft_name, fptr->ft_name, FILENMLEN);
#endif
			fptr->ft_status  = fe.u500->v5_ft_status;
			fptr->ft_type    = fe.u500->v5_ft_type;
			fptr->ft_slots   = fe.u500->v5_ft_slots;
			fptr->ft_slsize  = fe.u500->v5_ft_slsize;
			fptr->ft_pgsize  = fe.u500->v5_ft_pgsize;
			fptr->ft_flags   = fe.u500->v5_ft_flags;
			fptr->ft_pctincrease = fe.u500->v5_ft_pctincrease;
			fptr->ft_initial = fe.u500->v5_ft_initial;
			fptr->ft_next    = fe.u500->v5_ft_next;
			fptr->ft_index = -1;
			fptr->ft_lmtimestamp = 0;
			fptr->ft_cachetimestamp = 0;
			fe.u500++;
			break;
		}
	}

	n = curr_dbt->Size_rt * sizeof(RECORD_ENTRY);
	memcpy(&task->record_table[curr_dbt->rt_offset], sc->sc_records, n);
	
	if (curr_dbt->Size_fd)
	{
		n = curr_dbt->Size_fd * sizeof(FIELD_ENTRY);
		memcpy(&task->field_table[curr_dbt->fd_offset], sc->sc_fields, n);
	}
	
	if (curr_dbt->Size_st)
	{
		n = curr_dbt->Size_st * sizeof(SET_ENTRY);
		memcpy(&task->set_table[curr_dbt->st_offset], sc->sc_sets, n);
	}
	
	if (curr_dbt->Size_mt)
	{
		n = curr_dbt->Size_mt * sizeof(MEMBER_ENTRY);
		memcpy(&task->member_table[curr_dbt->mt_offset], sc->sc_members, n);
	}
	
	if (curr_dbt->Size_srt)
	{
		n = curr_dbt->Size_srt * sizeof(SORT_ENTRY);
		memcpy(&task->sort_table[curr_dbt->srt_offset], sc->sc_sorts, n);
	}
	
	if (curr_dbt->Size_kt)
	{
		n = curr_dbt->Size_kt * sizeof(KEY_ENTRY);
		memcpy(&task->key_table[curr_dbt->kt_offset], sc->sc_keys, n);
	}
	
	if (sc->sc_names && (task->dboptions & READNAMES)) {
		nlen = vtstrlen(sc->sc_names);
		if ((p = (DB_TCHAR *) psp_cGetMemory(nlen, 0)) == NULL)
			return dberr(S_NOMEMORY);
		
		if (task->dboptions & READNAMES)
		{
			curr_dbt->Objnames = p;
			getnames(task->record_names, &p, curr_dbt->rt_offset,
				(short) (curr_dbt->rt_offset + curr_dbt->Size_rt));
			getnames(task->field_names, &p, curr_dbt->fd_offset,
				(short) (curr_dbt->fd_offset + curr_dbt->Size_fd));
			getnames(task->set_names, &p, curr_dbt->st_offset,
				(short) (curr_dbt->st_offset + curr_dbt->Size_st));
		} else {
			DB_TCHAR *tmp = p;
			
			skipnames(&p, (short) (curr_dbt->Size_rt + curr_dbt->Size_fd +
				curr_dbt->Size_st));
		}
	}
	
	if (sc->sc_nsgdata == 16 && sc->sc_sgdata) {
		/* TODO: I don't know if SG seed should be malloc()ed? */
		DB_BYTE sg_data[16];
		memcpy(sg_data, sc->sc_sgdata, 16);
		if (!sg)
			return dberr(S_INVENCRYPT);
		else if (!(*sg->chk)(sg->data, p))
			return dberr(S_INVENCRYPT);
	} else if (sg)
		return dberr(S_INVENCRYPT);
	
	return S_OKAY;
}

/* ======================================================================
    Initialize database tables
*/
int INTERNAL_FCN inittab(DB_TASK *task, const SG *sg, const DB_SCHEMA * sc)
{
    register int        dbt_lc;
    register short      i;
    int                 stat = S_OKAY;
    short               key_offset;
    short               key_count;
    short               Max_Size_ft = 0;
    short               maxsize;
    int                 is_query_db;
    FILE_ENTRY         *fptr;
    RECORD_ENTRY       *rec_ptr;
    SET_ENTRY          *set_ptr;
    FIELD_ENTRY        *fld_ptr;
    MEMBER_ENTRY       *mem_ptr;
    SORT_ENTRY         *srt_ptr;
    KEY_ENTRY          *key_ptr;
    DB_ENTRY           *curr_dbt;
	struct DICT_SIZE    dict_size;
    DB_TCHAR            dbname[FILENMLEN]; /* Temporary working space */
	DB_TCHAR            dbfile[FILENMLEN];

    /* initialize (merged) dictionary values */
    if (task->no_of_dbs == 1)
        task->db_tsrecs = task->db_tssets = FALSE;

    key_offset = 0;

    key_offset = (short) task->no_of_keys;
    /* compute individual dictionary sizes and offsets */
    
	for (dbt_lc = task->old_no_of_dbs,
            curr_dbt = task->curr_db_table = &task->db_table[task->old_no_of_dbs];
            dbt_lc < task->no_of_dbs; ++dbt_lc, ++curr_dbt, ++task->curr_db_table)
    {
		if (sc == NULL)
			stat = get_dbd_dict_sizes(dbt_lc, &dict_size, task);
		else
			stat = get_sc_dict_sizes(dbt_lc, &dict_size, sc, task);

		if (stat != S_OKAY)
			return task->db_status;

        if (dict_size.Size_ft > Max_Size_ft)
            Max_Size_ft = dict_size.Size_ft;

        curr_dbt->Page_size = dict_size.Page_size;
        curr_dbt->Size_ft   = dict_size.Size_ft;
        curr_dbt->Size_rt   = dict_size.Size_rt;
        curr_dbt->Size_fd   = dict_size.Size_fd;
        curr_dbt->Size_st   = dict_size.Size_st;
        curr_dbt->Size_mt   = dict_size.Size_mt;
        curr_dbt->Size_srt  = dict_size.Size_srt;
        curr_dbt->Size_kt   = dict_size.Size_kt;

        curr_dbt->sysdba = NULL_DBA;

        /* update merged dictionary offsets and sizes */
        if (curr_dbt->Page_size > task->page_size)
            task->page_size = curr_dbt->Page_size;

        curr_dbt->ft_offset = task->size_ft;
        task->size_ft += curr_dbt->Size_ft;
        curr_dbt->rt_offset = task->size_rt;
        task->size_rt += curr_dbt->Size_rt;
        curr_dbt->fd_offset = task->size_fd;
        task->size_fd += curr_dbt->Size_fd;
        curr_dbt->st_offset = task->size_st;
        task->size_st += curr_dbt->Size_st;
        curr_dbt->mt_offset = task->size_mt;
        task->size_mt += curr_dbt->Size_mt;
        curr_dbt->srt_offset = task->size_srt;
        task->size_srt += curr_dbt->Size_srt;
        curr_dbt->kt_offset = task->size_kt;
        task->size_kt += curr_dbt->Size_kt;
    }

    /* allocate dictionary space */
    if (alloc_dict(task, sg) != S_OKAY)
        return task->db_status;

    /* read in and adjust dictionary entries for each database */
	for (dbt_lc = task->old_no_of_dbs,
            curr_dbt = task->curr_db_table = &task->db_table[task->old_no_of_dbs];
            dbt_lc < task->no_of_dbs; ++dbt_lc, ++curr_dbt, ++task->curr_db_table)
    {
		/* special check for db_query temporary database */
		is_query_db = (vtstricmp(curr_dbt->db_name, DB_TEXT("db_query")) == 0);

		if (sc == NULL)
			stat = load_dbd(dbt_lc, sg, task);
		else
			stat = load_schema(dbt_lc, sg, sc, task);

		if (stat != S_OKAY)
			return task->db_status;

        maxsize = 0;
        fptr = &task->file_table[curr_dbt->ft_offset];
        for (i = 0; i < curr_dbt->Size_ft; i++, fptr++)
        {
             if (fptr->ft_pgsize > maxsize)
                 maxsize = fptr->ft_pgsize;
        }

        if (maxsize > task->enc_size)
        {
            task->enc_buff = psp_extendMemory(task->enc_buff, maxsize, 0);
            task->enc_size = maxsize;
        }

        curr_dbt->key_offset = key_offset;

        /* update file table path entries */
        if (curr_dbt->db_path[0] || task->dbfpath[0])
        {
            for ( i = 0, fptr = &task->file_table[curr_dbt->ft_offset];
                  i < curr_dbt->Size_ft; ++i, ++fptr)
            {
                /* Construct the data/key file name */
                if (curr_dbt->db_path[0])
                    vtstrcpy(dbname, curr_dbt->db_path);
                else
                    dbname[0] = DB_TEXT('\0');

                if (vtstrlen(dbname) + vtstrlen(curr_dbt->db_name) >= FILENMLEN + 4)
                    return (dberr(S_NAMELEN));

                vtstrcat(dbname, curr_dbt->db_name);
                if (con_dbf(dbfile, fptr->ft_name, dbname,
                        get_element(task->dbfpath, dbt_lc), task) != S_OKAY)
                    return (task->db_status);

                /* Save new name in dictionary */
                vtstrcpy(fptr->ft_name, dbfile);
            }
        }

        /* make db_query's files temporary so they don't get sent
            to the lock manager.
        */
        if (is_query_db)
        {
            for ( i = 0, fptr = &task->file_table[curr_dbt->ft_offset];