Пример #1
0
Файл: HDD.cpp Проект: ss23/rpcs3
void vfsHDDManager::CreateHDD(const std::string& path, u64 size, u64 block_size)
{
	fs::file f(path, fom::rewrite);

	static const u64 cur_dir_block = 1;

	vfsHDD_Hdr hdr;
	CreateBlock(hdr);
	hdr.next_block = cur_dir_block;
	hdr.magic = g_hdd_magic;
	hdr.version = g_hdd_version;
	hdr.block_count = (size + block_size) / block_size;
	hdr.block_size = block_size;
	f.write(&hdr, sizeof(vfsHDD_Hdr));

	{
		vfsHDD_Entry entry;
		CreateEntry(entry);
		entry.type = vfsHDD_Entry_Dir;
		entry.data_block = hdr.next_block;
		entry.next_block = 0;

		f.seek(cur_dir_block * hdr.block_size);
		f.write(&entry, sizeof(vfsHDD_Entry));
		f.write(".", 1);
	}

	u8 null = 0;

	CHECK_ASSERTION(f.seek(hdr.block_count * hdr.block_size - sizeof(null)) != -1);
	
	f.write(&null, sizeof(null));
}
Пример #2
0
//---------------------------------------------------------------------------
// 辞書への単語の追加
// 既に単語が存在する場合でも、さらに追加する (現在の仕様)
// 既に単語が存在する場合には、出現確率を変更する (将来の仕様)
// 戻り値 : 追加した単語のID
TWordID TNS_KawariDictionary::Insert(TEntryID entry,TKawariCode_base* word)
{
	if(!word) return(0);

	// エントリ内の単語はコンテキストを持つ
	word=word->CreateContext();

	TWordID id=0;
	if(!WordCollection.Insert(word,&id)) {
		// 既に登録済みの単語だった
		delete word;
		word=GetWordFromID(id);
	}

	TKawariCodeEntryCall *macro=dynamic_cast<TKawariCodeEntryCall *>(word);
	if(macro) {
		// 追加するのは純粋仮想単語
		TEntryID child=CreateEntry(macro->Get());

		PVWToEntry[id]=child;
		EntryToPVW[child]=id;
	}

	Dictionary[entry].push_back(id);
	ReverseDictionary[id].insert(entry);

	return(id);
}
Пример #3
0
void 
GiSTnode::Unpack(const char *page)
{
    const GiSTheader *h = (const GiSTheader *) page;

    Reset();

    SetLevel(h->level);
    SetSibling(h->sibling);

    if (!packedNode)
	packedNode = new char[tree->Store()->PageSize()];
    memcpy(packedNode, page, tree->Store()->PageSize());

    Expand(h->numEntries);
    SetNumEntries(h->numEntries);

    for (int i=0; i<h->numEntries; i++) {
        GiSTcompressedEntry tmpentry = Entry(i);
	GiSTentry *e = CreateEntry();
	e->SetLevel(Level());
	e->SetPosition(i);
	e->SetNode(this);
	e->Decompress(tmpentry);
	// be tidy
	if (tmpentry.key)
	  delete tmpentry.key;

	// Append the body with the entry
	entries[i] = e;
    }
}
Пример #4
0
struct entry *ReadEntryData(struct entry *Top)
{
  //この関数は戻り値がstruct型の、引数はentryのポインタを渡す関数
  struct entry *ep;
  char *cp, *tp;
  char buf[512];
  char name[32];
  char sex;
  int age;

//while(継続条件) {} ここではfgets関数が読み込んだ値の中身がNULLじゃなかったら、という条件の時こうする
//fgets関数は第一引数は文字配列のポインタ第二引数は一行の最大文字数
  //第三引数はファイルポインタ標準入力を指定する場合はファイルポインタに「stdin」と書く。すると入力した値がbufに入る
  while (fgets(buf, sizeof(buf), stdin) != NULL) {
      //while文で読み込んでいる fgtes関数を使って、一行も文字列を読み込んでいる
    /*
     * Node setup
     */
    if (Top == NULL) {
      Top = CreateEntry();//epを返り血にした後で、それをTopにいれて、またepに戻す
      ep = Top;//TOPがなければ、C一つのノードをつくって、それをTOPにする
    } else {//一つでもリスト構造が有るなら、一番ケツに新しいエントリーをつける?
        //epという変数に、一番最後が入ってる?
      for (ep = Top; ep->next != NULL; ep = ep->next);
      ep->next = CreateEntry();//CreateEntry関数は一番最後にNULLをいれて返す
      ep = ep->next;
    }


//ここから下の処理がイマイチわからない
    cp = buf;//入力させた値をポインタcpに入れる
    tp = cp;//その後にポインタtpに入れる
    if((cp = index(tp, ' ')) == NULL) {
      fprintf(stderr, "Input format fail: %s\n", tp);
      exit(-1);
    }
    *cp++ = '\0';//cpを++することで、\0をいれて文字列の終了をした後に、次のところに行っている
    strcpy(ep->name, tp);
    
    ep->sex = *cp++;
    cp++;

    ep->age = atoi(cp);//ageがでてくるのはここだけ!atoi関数は文字列で表現された数値をint型の数値に変換する。変換不能なアルファベットなどの文字列の場合は0を返すが、数値が先頭にあればその値を返す。
  }
  return (Top);
}
Пример #5
0
void initialise_hashmaps()
{
    for(int i=0;i<ENTRY_LEN;i++)
    {
        _entries[i] = CreateEntry(NULL);
        _lasts[i] = _entries[i];
    }
}
Пример #6
0
JSON *entry_type_parse(){
    next_non_space_char(); // get char '"'
    JSON *key_obj = string_type_parse();
    next_non_space_char();
    assert(str_value() == ':');
    next_char();
    JSON *value_obj = non_type_parse();
    return CreateEntry(key_obj->valuestring, value_obj);
}
Пример #7
0
/*----------------------------------------------------------------------
|   TestRemoveDirectory
+---------------------------------------------------------------------*/
void
TestRemoveDirectory()
{
    NPT_DirectoryEntryInfo info;
    NPT_String             path;
    NPT_Result             res;

    // read path from environment variable
    res = NPT_GetEnvironment("NEPTUNE_TEST_ROOT", path);
    CHECK(NPT_SUCCEEDED(res));

    // find the next directory path that does not exist
    res = FindNextAvailableDirectory(path, path);
    CHECK(NPT_SUCCEEDED(res));

    // create directory object
    res = NPT_DirectoryCreate(path, true);
    CHECK(NPT_SUCCEEDED(res));

    // create some subdirectories
    res = CreateEntry(path, "foof1", true);
    CHECK(NPT_SUCCEEDED(res));
    res = CreateEntry(path, "foof2", true);
    CHECK(NPT_SUCCEEDED(res));
    res = CreateEntry(path, "foof2.dir", true);
    CHECK(NPT_SUCCEEDED(res));

    // create some files
    res = CreateEntry(path, "foo1", false);
    CHECK(NPT_SUCCEEDED(res));
    res = CreateEntry(path, "foo2.", false);
    CHECK(NPT_SUCCEEDED(res));
    res = CreateEntry(path, "foo2.e", false);
    CHECK(NPT_SUCCEEDED(res));
    res = CreateEntry(path, "foo2.e3", false);
    CHECK(NPT_SUCCEEDED(res));
    res = CreateEntry(path, "foo2.gas", false);
    CHECK(NPT_SUCCEEDED(res));
    res = CreateEntry(path, "foo4.tee", false);
    CHECK(NPT_SUCCEEDED(res));

    // remove directory
    res = NPT_DirectoryRemove(path, true);
    CHECK(NPT_SUCCEEDED(res));

    // verify directory does not exist any more
    res = NPT_DirectoryEntry::GetInfo(path, &info);
    CHECK(res == NPT_ERROR_NO_SUCH_ITEM);
}
Пример #8
0
bool DOS_Drive_Cache::ReadDir(Bit16u id, char* &result) {
	// shouldnt happen...
	if (id>MAX_OPENDIRS) return false;

	if (!IsCachedIn(dirSearch[id])) {
		// Try to open directory
		dir_information* dirp = open_directory(dirPath);
		if (!dirp) {
			if (dirSearch[id]) {
				dirSearch[id]->id = MAX_OPENDIRS;
				dirSearch[id] = 0;
			}
			return false;
		}
		// Read complete directory
		char dir_name[CROSS_LEN];
		bool is_directory;
		if (read_directory_first(dirp, dir_name, is_directory)) {
			CreateEntry(dirSearch[id], dir_name, is_directory);
			while (read_directory_next(dirp, dir_name, is_directory)) {
				CreateEntry(dirSearch[id], dir_name, is_directory);
			}
		}

		// close dir
		close_directory(dirp);

		// Info
/*		if (!dirp) {
			LOG_DEBUG("DIR: Error Caching in %s",dirPath);			
			return false;
		} else {	
			char buffer[128];
			sprintf(buffer,"DIR: Caching in %s (%d Files)",dirPath,dirSearch[srchNr]->fileList.size());
			LOG_DEBUG(buffer);
		};*/
	};
	if (SetResult(dirSearch[id], result, dirSearch[id]->nextEntry)) return true;
	if (dirSearch[id]) {
		dirSearch[id]->id = MAX_OPENDIRS;
		dirSearch[id] = 0;
	}
	return false;
}
Пример #9
0
JSON *Duplicate(JSON *obj, int recurse){
    switch (obj->type){
        case JSON_NULL:
            return CreateNULL();
        case JSON_TRUE:
            return CreateTrue();
        case JSON_FALSE:
            return CreateFalse();
        case JSON_NUMBER:
            return CreateNumber(obj->valuedouble);
        case JSON_STRING:
            return CreateString(obj->valuestring);
        case JSON_ARRAY:{
            JSON *new_obj = CreateArray();
            if (recurse == 0)
                new_obj->son = obj->son;
            else{
                if (obj->son != NULL){
                    new_obj->son = Duplicate(obj->son, 1);
                    JSON *old_item = obj->son, *new_item = new_obj->son;
                    for ( ; old_item->next != NULL; old_item = old_item->next, new_item = new_item->next){
                        JSON *temp = Duplicate(old_item->next,1);
                        new_item->next = temp;
                        temp->last = new_item;
                    }
                }
            }
            return new_obj;
        }
        case JSON_OBJECT:{
            JSON *new_obj = CreateObject();
            if (recurse == 0)
                new_obj->son = obj->son;
            else{
                if (obj->son != NULL){
                    new_obj->son = Duplicate(obj->son, 1);
                    JSON *old_item = obj->son, *new_item = new_obj->son;
                    for ( ; old_item->next != NULL; old_item = old_item->next, new_item = new_item->next){
                        JSON *temp = Duplicate(old_item->next,1);
                        new_item->next = temp;
                        temp->last = new_item;
                    }
                }
            }
            return new_obj;
        }
        case JSON_ENTRY:{
            JSON *new_obj = CreateEntry(obj->key, Duplicate(obj->value,1));
            return new_obj;
        }
        default:
            return NULL;
    }
}
Пример #10
0
struct entry *ReadEntryData(struct entry *Top)
{
  struct entry *ep;
  char *cp, *tp;
  char buf[512];
  char name[32];
  char sex;
  int age;


  while (fgets(buf, sizeof(buf), stdin) != NULL) {
    /*
     * Node setup
     */
    if (Top == NULL) {
      Top = CreateEntry();
      ep = Top;
    } else {
      ep->next = CreateEntry();
      ep = ep->next;
    }

    cp = buf;
    tp = cp;
    if((cp = index(tp, ' ')) == NULL) {
      fprintf(stderr, "Input format fail: %s\n", tp);
      exit(-1);
    }
    *cp++ = '\0';
    strcpy(ep->name, tp);
    
    ep->sex = *cp++;
    cp++;

    ep->age = atoi(cp);
  }
  return (Top);
}
Пример #11
0
void add_cell(Node *cell)
{
    #ifdef PRINT_CALL_MAP
        std::cout<<"P";
    #endif
    int key = calculate_hash((size_t)(cell->offset + _buffers->data));
    Entry *en = _entries[key];

    while(en->next)
        en = en->next;

    _lasts[key]->next = CreateEntry(cell);
//    en->next = CreateEntry(cell);
}
Пример #12
0
BOOL CAutoReg::AddEntry(	HKEY hKey, LPCTSTR pKey, DWORD dwType,
						LPCTSTR pName, void* pvoidData, DWORD dwLength,
						DWORD dwDef, void* pvoidDef, DWORD dwDefLength,
						DWORD dwUser, LPCTSTR pComputer )
{_STTEX();
	CAutoRegEntry reg;

	// Fill in the data
	CreateEntry(	&reg, hKey, pKey, dwType, pName, pvoidData, dwLength,
					dwDef, pvoidDef, dwDefLength, dwUser, pComputer );

	// Add it to the list
	m_Entrys += reg;

	return TRUE;
}
bool D3DVertexBufferCache::InitBuffer(D3DDevice *d3d, BYTE *data, int size, CacheEntryInfo &info)
{
   assert(d3d != NULL);
   assert(data != NULL);
   assert(size > 0);

   int best = FindBestEntry(size);
   CacheEntry *ce = NULL;

   // Reallocate
   if (best >= 0 && _cache[best].size < size)
   {
      DeleteEntry(best);
      best = -1;
   }

   // New
   if (best < 0)
   {
      CacheEntry new_entry;
      if (!CreateEntry(d3d, new_entry, size))
      {
	WRN("Failed to create new vbcache entry");
         return false;
      }
      _cache.Add(new_entry);
      info.id = _cache.Length() - 1;
      ce = _cache.Last();
   }
   else
   {
      info.id = best;
      ce = &_cache[best];
   }

   assert(ce != NULL);
   if (!InsertData(*ce, data, size))
   {
      WRN("Failed to insert vbcache data");
      return false;
   }
   return true;
}
Пример #14
0
//---------------------------------------------------------------------------
TWordID TNS_KawariDictionary::Insert(TEntryID entry,TWordID id)
{
	if(id==0) return(0);

	TKawariCode_base* word=GetWordFromID(id);
	if(word==NULL) return(0);

	TKawariCodeEntryCall *macro=dynamic_cast<TKawariCodeEntryCall *>(word);
	if(macro) {
		// 追加するのは純粋仮想単語
		TEntryID child=CreateEntry(macro->Get());

		PVWToEntry[id]=child;
		EntryToPVW[child]=id;
	}

	Dictionary[entry].push_back(id);
	ReverseDictionary[id].insert(entry);

	return(id);
}
Пример #15
0
NS_IMETHODIMP
nsParserService::RegisterObserver(nsIElementObserver* aObserver,
                                  const nsAString& aTopic,
                                  const eHTMLTags* aTags)
{
  nsresult result = NS_OK;
  nsObserverEntry* entry = GetEntry(aTopic);

  if(!entry) {
    result = CreateEntry(aTopic,&entry);
    NS_ENSURE_SUCCESS(result,result);
  }

  while (*aTags) {
    if (*aTags <= NS_HTML_TAG_MAX) {
      entry->AddObserver(aObserver,*aTags);
    }
    ++aTags;
  }

  return result;
}
Пример #16
0
int AcuArchive::LoadContents(void)
{
    NuError nerr;
    int numEntries;

    ASSERT(fFp != NULL);
    rewind(fFp);

    /*
     * Read the master header.  In an ACU file this holds the number of
     * files and a bunch of stuff that doesn't seem to change.
     */
    if (ReadMasterHeader(&numEntries) != 0)
        return -1;

    while (numEntries) {
        AcuFileEntry fileEntry;

        nerr = ReadFileHeader(&fileEntry);
        if (nerr != kNuErrNone)
            return 1;

        if (CreateEntry(&fileEntry) != 0)
            return 1;

        /* if file isn't empty, seek past it */
        if (fileEntry.dataStorageLen) {
            nerr = AcuSeek(fileEntry.dataStorageLen);
            if (nerr != kNuErrNone)
                return 1;
        }

        numEntries--;
    }

    return 0;
}
Пример #17
0
/**
Creates a new entry as a child of the current context as part of a
bulk creation operation. The entry will not be committed to file immediately.

The parent ID and entry ID are set by the Message Server.

@param	aEntry
Index entry value for the new entry

@param	aOwnerId
The SID of the process that will own the create entry.

@return
KErrNone - success; KErrNoMemory - a memory allocation failed;
KErrNotSupported - aEntry is invalid
*/
EXPORT_C TInt CMsvServerEntry::CreateEntryBulk(TMsvEntry& aEntry, TSecureId aOwnerId)
	{
	return CreateEntry(aEntry, aOwnerId, ETrue);
	}
Пример #18
0
char* DOS_Drive_Cache::GetExpandName(const char* path) {
	static char work [CROSS_LEN] = { 0 };
	char dir [CROSS_LEN]; 

	work[0] = 0;
	strcpy (dir,path);

	const char* pos = strrchr(path,CROSS_FILESPLIT);

	if (pos) dir[pos-path+1] = 0;
	CFileInfo* dirInfo = FindDirInfo(dir, work);
		
	if (pos) {
		// Last Entry = File
		strcpy(dir,pos+1); 
		GetLongName(dirInfo, dir);
		strcat(work,dir);
	}

	if (*work) {
		size_t len = strlen(work);
#if defined (WIN32) 
		if((work[len-1] == CROSS_FILESPLIT ) && (len >= 2) && (work[len-2] != ':')) {
#else
		if((len > 1) && (work[len-1] == CROSS_FILESPLIT )) {
#endif       
			work[len-1] = 0; // Remove trailing slashes except when in root
		}
	}
	return work;
}

void DOS_Drive_Cache::AddEntry(const char* path, bool checkExists) {
	// Get Last part...
	char file	[CROSS_LEN];
	char expand	[CROSS_LEN];

	CFileInfo* dir = FindDirInfo(path,expand);
	const char* pos = strrchr(path,CROSS_FILESPLIT);

	if (pos) {
		strcpy(file,pos+1);	
		// Check if file already exists, then don't add new entry...
		if (checkExists) {
			if (GetLongName(dir,file)>=0) return;
		}

		CreateEntry(dir,file,false);

		Bits index = GetLongName(dir,file);
		if (index>=0) {
			Bit32u i;
			// Check if there are any open search dir that are affected by this...
			if (dir) for (i=0; i<MAX_OPENDIRS; i++) {
				if ((dirSearch[i]==dir) && ((Bit32u)index<=dirSearch[i]->nextEntry)) 
					dirSearch[i]->nextEntry++;
			}
		}
		//		LOG_DEBUG("DIR: Added Entry %s",path);
	} else {
//		LOG_DEBUG("DIR: Error: Failed to add %s",path);	
	}
}
Пример #19
0
static int
CommandProc(struct cmd_syndesc *a_as, void *arock)
{
    int i;
    long code = 0;
    long upos;
    long gpos = 0;
    struct prentry uentry, gentry;
    struct ubik_hdr *uh;
    char *dfile = 0;
    const char *pbase = AFSDIR_SERVER_PRDB_FILEPATH;
    char *pfile = NULL;
    char pbuffer[1028];
    struct cmd_parmdesc *tparm;

    tparm = a_as->parms;

    if (tparm[0].items) {
	wflag++;
	/* so we are treated as admin and can create "mis"owned
	   groups */
	pr_noAuth = 1;
    }
    if (tparm[1].items) {
	flags |= DO_USR;
    }
    if (tparm[2].items) {
	flags |= DO_GRP;
    }
    if (tparm[3].items) {
	flags |= (DO_GRP | DO_MEM);
    }
    if (tparm[4].items) {
	nflag++;
    }
    if (tparm[5].items) {
	flags |= DO_SYS;
    }
    if (tparm[6].items) {
	flags |= DO_OTR;
    }
    if (tparm[7].items) {
	pfile = tparm[7].items->data;
    }
    if (tparm[8].items) {
	dfile = tparm[8].items->data;
    }

    if (pfile == NULL) {
        snprintf(pbuffer, sizeof(pbuffer), "%s.DB0", pbase);
        pfile = pbuffer;
    }
    if ((dbase_fd = open(pfile, (wflag ? O_RDWR : O_RDONLY) | O_CREAT, 0600))
	< 0) {
	fprintf(stderr, "pt_util: cannot open %s: %s\n", pfile,
		strerror(errno));
	exit(1);
    }
    if (read(dbase_fd, buffer, HDRSIZE) < 0) {
	fprintf(stderr, "pt_util: error reading %s: %s\n", pfile,
		strerror(errno));
	exit(1);
    }

    if (dfile) {
	if ((dfp = fopen(dfile, wflag ? "r" : "w")) == 0) {
	    fprintf(stderr, "pt_util: error opening %s: %s\n", dfile,
		    strerror(errno));
	    exit(1);
	}
    } else
	dfp = (wflag ? stdin : stdout);

    uh = (struct ubik_hdr *)buffer;
    if (ntohl(uh->magic) != UBIK_MAGIC)
	fprintf(stderr, "pt_util: %s: Bad UBIK_MAGIC. Is %x should be %x\n",
		pfile, ntohl(uh->magic), UBIK_MAGIC);
    memcpy(&uv, &uh->version, sizeof(struct ubik_version));

    if (wflag && ntohl(uv.epoch) == 0 && ntohl(uv.counter) == 0) {
	uv.epoch = htonl(2); /* a ubik version of 0 or 1 has special meaning */
	memcpy(&uh->version, &uv, sizeof(struct ubik_version));
	lseek(dbase_fd, 0, SEEK_SET);
	if (write(dbase_fd, buffer, HDRSIZE) < 0) {
	    fprintf(stderr, "pt_util: error writing ubik version to %s: %s\n",
		    pfile, strerror(errno));
	    exit(1);
	}
    }

    /* Now that any writeback is done, swap these */
    uv.epoch = ntohl(uv.epoch);
    uv.counter = ntohl(uv.counter);

    fprintf(stderr, "Ubik Version is: %d.%d\n", uv.epoch, uv.counter);
    if (read(dbase_fd, &prh, sizeof(struct prheader)) < 0) {
	fprintf(stderr, "pt_util: error reading %s: %s\n", pfile,
		strerror(errno));
	exit(1);
    }

    Initdb();
    initialize_PT_error_table();

    if (wflag) {
	struct usr_list *u;
	int seenGroup = 0, id = 0, flags = 0;

	while (fgets(buffer, sizeof(buffer), dfp)) {
	    int oid, cid, quota, uid;
	    char name[PR_MAXNAMELEN], mem[PR_MAXNAMELEN];

	    if (isspace(*buffer)) {
		code = sscanf(buffer, "%s %d", mem, &uid);
		if (code != 2) {
		    fprintf(stderr,
			    "Insuffient data provided for group membership\n");
		    exit(1);
		}

		if (!seenGroup) {
		    fprintf(stderr,
			    "Group member %s listed outside of group\n",
			    mem);
		    exit(1);
		}

		for (u = usr_head; u; u = u->next)
		    if (u->uid && u->uid == uid)
			break;
		if (u) {
		    /* Add user - deferred because it is probably foreign */
		    u->uid = 0;
		    if (FindByID(0, uid))
			code = PRIDEXIST;
		    else {
			if (!code
			    && (flags & (PRGRP | PRQUOTA)) ==
			    (PRGRP | PRQUOTA)) {
			    gentry.ngroups++;
			    code = pr_WriteEntry(0, 0, gpos, &gentry);
			    if (code)
				fprintf(stderr,
					"Error setting group count on %s: %s\n",
					name, afs_error_message(code));
			}
			code = CreateEntry(0, u->name, &uid, 1 /*idflag */ ,
					   1 /*gflag */ ,
					   SYSADMINID /*oid */ ,
					   SYSADMINID /*cid */ );
		    }
		    if (code)
			fprintf(stderr, "Error while creating %s: %s\n",
				u->name, afs_error_message(code));
		    continue;
		}
		/* Add user to group */
		if (id == ANYUSERID || id == AUTHUSERID || uid == ANONYMOUSID) {
		    code = PRPERM;
		} else if ((upos = FindByID(0, uid))
			   && (gpos = FindByID(0, id))) {
		    code = pr_ReadEntry(0, 0, upos, &uentry);
		    if (!code)
			code = pr_ReadEntry(0, 0, gpos, &gentry);
		    if (!code)
			code = AddToEntry(0, &gentry, gpos, uid);
		    if (!code)
			code = AddToEntry(0, &uentry, upos, id);
		} else
		    code = PRNOENT;

		if (code)
		    fprintf(stderr, "Error while adding %s to %s: %s\n", mem,
			    name, afs_error_message(code));
	    } else {
		code = sscanf(buffer, "%s %d/%d %d %d %d", name, &flags, &quota, &id,
			      &oid, &cid);
		if (code != 6) {
		    fprintf(stderr,
			    "Insufficient data provided for user/group\n");
		    exit(1);
		}

		seenGroup = 1;

		if (FindByID(0, id))
		    code = PRIDEXIST;
		else
		    code = CreateEntry(0, name, &id, 1 /*idflag */ ,
				       flags & PRGRP, oid, cid);
		if (code == PRBADNAM) {
		    u = malloc(sizeof(struct usr_list));
		    u->next = usr_head;
		    u->uid = id;
		    strcpy(u->name, name);
		    usr_head = u;
		} else if (code) {
		    fprintf(stderr, "Error while creating %s: %s\n", name,
			    afs_error_message(code));
		} else if ((flags & PRACCESS)
			   || (flags & (PRGRP | PRQUOTA)) ==
			   (PRGRP | PRQUOTA)) {
		    gpos = FindByID(0, id);
		    code = pr_ReadEntry(0, 0, gpos, &gentry);
		    if (!code) {
			gentry.flags = flags;
			gentry.ngroups = quota;
			code = pr_WriteEntry(0, 0, gpos, &gentry);
		    }
		    if (code)
			fprintf(stderr,
				"Error while setting flags on %s: %s\n", name,
				afs_error_message(code));
		}
	    }
	}
	for (u = usr_head; u; u = u->next)
	    if (u->uid)
		fprintf(stderr, "Error while creating %s: %s\n", u->name,
			afs_error_message(PRBADNAM));
    } else {
	for (i = 0; i < HASHSIZE; i++) {
	    upos = nflag ? ntohl(prh.nameHash[i]) : ntohl(prh.idHash[i]);
	    while (upos) {
		long newpos;
		newpos = display_entry(upos);
		if (newpos == upos) {
		    fprintf(stderr, "pt_util: hash error in %s chain %d\n",
			    nflag ? "name":"id", i);
		    exit(1);
		} else
		    upos = newpos;
	    }
	}
	if (flags & DO_GRP)
	    display_groups();
    }

    lseek(dbase_fd, 0, L_SET);	/* rewind to beginning of file */
    if (read(dbase_fd, buffer, HDRSIZE) < 0) {
	fprintf(stderr, "pt_util: error reading %s: %s\n", pfile,
		strerror(errno));
	exit(1);
    }
    uh = (struct ubik_hdr *)buffer;

    uh->version.epoch = ntohl(uh->version.epoch);
    uh->version.counter = ntohl(uh->version.counter);

    if ((uh->version.epoch != uv.epoch)
	|| (uh->version.counter != uv.counter)) {
	fprintf(stderr,
		"pt_util: Ubik Version number changed during execution.\n");
	fprintf(stderr, "Old Version = %d.%d, new version = %d.%d\n",
		uv.epoch, uv.counter, uh->version.epoch, uh->version.counter);
    }
    close(dbase_fd);
    exit(0);
}
Пример #20
0
LOCAL_C void TestMultipleNotifsL()
{
    CMultipleSessionObserver* ob = new(ELeave) CMultipleSessionObserver;
    CleanupStack::PushL(ob);

    CMsvSession* session = CMsvSession::OpenSyncL(*ob);
    CleanupStack::PushL(session);

    CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
    CleanupStack::PushL(cEntry);

    CEntryObserver* entryOb1=new (ELeave) CEntryObserver;
    CleanupStack::PushL(entryOb1);
    cEntry->AddObserverL(*entryOb1);

    CTestActive* active = new (ELeave) CTestActive;
    CleanupStack::PushL(active);

    CMsvOperation* operation;
    CMsvEntrySelection* selection;

    // create folders to work under
    TMsvEntry folder1;
    folder1.iDescription.Set(KShortDescription);
    folder1.iDetails.Set(KShortDetails);
    folder1.iType = KUidMsvFolderEntry;
    folder1.iMtm = KUidMsvLocalServiceMtm;
    folder1.iServiceId = KMsvLocalServiceIndexEntryId;

    TMsvEntry folder2;
    folder2.iDescription.Set(KShortDescription);
    folder2.iDetails.Set(KShortDetails);
    folder2.iType = KUidMsvFolderEntry;
    folder2.iMtm = KUidMsvLocalServiceMtm;
    folder2.iServiceId = KMsvLocalServiceIndexEntryId;

    TMsvEntry folder3;
    folder3.iDescription.Set(KShortDescription);
    folder3.iDetails.Set(KShortDetails);
    folder3.iType = KUidMsvFolderEntry;
    folder3.iMtm = KUidMsvLocalServiceMtm;
    folder3.iServiceId = KMsvLocalServiceIndexEntryId;

    // create all th entries
    TMsvEntry entry;
    entry.iDescription.Set(KShortDescription);
    entry.iDetails.Set(KShortDetails);
    entry.iType = KUidMsvFolderEntry;
    entry.iMtm = KUidMsvLocalServiceMtm;
    entry.iServiceId = KMsvLocalServiceIndexEntryId;

    // create folder 2 & 3
    cEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);
    CreateEntry(folder2, *cEntry, KErrNone, *entryOb1);
    CreateEntry(folder3, *cEntry, KErrNone, *entryOb1);

    TMsvLocalOperationProgress prog;

    TInt max = 2*TMsvPackedChangeNotification::KMsvPackedChangeLimit+4;
    for (TInt count=1; count<=max; count++)
    {
        test.Printf(_L("."));

        // create another entry under folder 2
        cEntry->SetEntryL(folder2.Id());
        CreateEntry(entry, *cEntry, KErrNone, *entryOb1);

        // create folder1
        cEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);
        CreateEntry(folder1, *cEntry, KErrNone, *entryOb1);

        // test
        cEntry->SetEntryL(folder3.Id());
        selection = cEntry->ChildrenL();
        test(selection->Count()==0);
        delete selection;

        // copy all entries to folder 3
        ob->Start(MMsvSessionObserver::EMsvEntriesCreated, folder3.Id());
        cEntry->SetEntryL(folder2.Id());
        selection = cEntry->ChildrenL();
        test(selection->Count()==count);
        active->StartL();
        operation = cEntry->CopyL(*selection, folder3.Id(), active->iStatus);
        delete selection;
        CActiveScheduler::Start(); // operation complete
        test(operation->iStatus.Int()==KErrNone);
        test(operation->Mtm()==KUidMsvLocalServiceMtm);
        test(operation->Service()==KMsvLocalServiceIndexEntryId);
        prog = McliUtils::GetLocalProgressL(*operation);
        test(prog.iTotalNumberOfEntries==count);
        test(prog.iNumberCompleted==count);
        test(prog.iNumberFailed==0);
        test(prog.iError==KErrNone);
        delete operation;
        operation=NULL;
        // test
        cEntry->SetEntryL(folder3.Id());
        selection = cEntry->ChildrenL();
        test(selection->Count()==count);
        delete selection;
        if (ob->iEvents>1)
            test(ob->iSelection.Count()>TMsvPackedChangeNotification::KMsvPackedChangeLimit);
        else if (count>TMsvPackedChangeNotification::KMsvPackedChangeLimit)
        {
            ob->Wait();
            CActiveScheduler::Start();
        }
        // test
        selection = cEntry->ChildrenL();
        test(selection->Count()==count);
        delete selection;
        if (ob->iEvents>2)
            test(ob->iSelection.Count()>2*TMsvPackedChangeNotification::KMsvPackedChangeLimit);
        else if (count>2*TMsvPackedChangeNotification::KMsvPackedChangeLimit)
        {
            ob->Wait();
            CActiveScheduler::Start();
        }
        test(ob->iSelection.Count()==count);
        ob->Finish();

        // move all entries to folder 1
        selection = cEntry->ChildrenL();
        test(selection->Count()==count);
        ob->Start(MMsvSessionObserver::EMsvEntriesMoved, folder1.Id(), folder3.Id());
        active->StartL();
        operation = cEntry->MoveL(*selection, folder1.Id(), active->iStatus);
        delete selection;
        CActiveScheduler::Start(); // operation complete
        test(operation->iStatus.Int()==KErrNone);
        test(operation->Mtm()==KUidMsvLocalServiceMtm);
        test(operation->Service()==KMsvLocalServiceIndexEntryId);
        prog = McliUtils::GetLocalProgressL(*operation);
        test(prog.iTotalNumberOfEntries==count);
        test(prog.iNumberCompleted==count);
        test(prog.iNumberFailed==0);
        test(prog.iError==KErrNone);
        delete operation;
        operation=NULL;
        cEntry->SetEntryL(folder1.Id());
        selection = cEntry->ChildrenL();
        test(selection->Count()==count);
        delete selection;
        if (ob->iEvents>1)
            test(ob->iSelection.Count()>TMsvPackedChangeNotification::KMsvPackedChangeLimit);
        else if (count>TMsvPackedChangeNotification::KMsvPackedChangeLimit)
        {
            test(ob->iEvents==1);
            ob->Wait();
            CActiveScheduler::Start();
            test(ob->iEvents==2);
        }
        if (ob->iEvents>2)
            test(ob->iSelection.Count()>2*TMsvPackedChangeNotification::KMsvPackedChangeLimit);
        else if (count>2*TMsvPackedChangeNotification::KMsvPackedChangeLimit)
        {
            test(ob->iEvents==2);
            ob->Wait();
            CActiveScheduler::Start();
            test(ob->iEvents==3);
        }
        test(ob->iSelection.Count()==count);
        ob->Finish();


        // delete them
        ob->Start(MMsvSessionObserver::EMsvEntriesDeleted, KMsvGlobalInBoxIndexEntryId);
        cEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);
        active->StartL();
        operation = cEntry->DeleteL(folder1.Id(), active->iStatus);
        CActiveScheduler::Start(); // operation complete
        test(operation->iStatus.Int()==KErrNone);
        test(operation->Mtm()==KUidMsvLocalServiceMtm);
        test(operation->Service()==KMsvLocalServiceIndexEntryId);
        prog = McliUtils::GetLocalProgressL(*operation);
        test(prog.iTotalNumberOfEntries==1);
        test(prog.iNumberFailed==0);
        test(prog.iError==KErrNone);
        delete operation;
        operation=NULL;
        if (count+1>TMsvPackedChangeNotification::KMsvPackedChangeLimit && ob->iEvents==1)
        {
            ob->Wait();
            CActiveScheduler::Start();
        }
        if (count+1>2*TMsvPackedChangeNotification::KMsvPackedChangeLimit && ob->iEvents==2)
        {
            ob->Wait();
            CActiveScheduler::Start();
        }
        test(ob->iSelection.Count()==count+1);
        ob->Finish();
    }

    test.Printf(_L("\n"));
    CleanupStack::PopAndDestroy(5);
}
Пример #21
0
//-----------------------------------------------------------------------------------------//
bool Set( hash_table_t *ht,
		  uint8_t      *key,
		  size_t        keySize,
		  uint8_t      *value,
		  size_t        valueSize )
	{
	assert( ht != NULL );
	if( key == NULL || keySize == 0 || value == NULL || valueSize == 0 )
		return false;
	
	uint32_t hash = CalcHash( key, keySize );
	uint32_t index = hash % TABLE_SIZE;
	bucket_t *bucket = ht->buckets + index;
	entry_t *ent = bucket->entry;
	entry_t *prev = NULL;
	entry_t *unused = NULL;
	
	// search entry that matchs one of below condition.
	// * duplicated key
	// * unused entry
	for(; ent != NULL; prev = ent, ent = ent->next )
		{
		if( ent->hash == hash &&
			ent->keySize == keySize &&
			memcmp( ent->key, key, ent->keySize ) == 0 )
			{
			// duplicated key found.
			break;
			}

		if( ent->isUsed == false )
			{
			// save unused entry.
			unused = ent;
			}
		}

	// if no duplicated key entry found,
	// then set "unused" to "ent" for reusing.
	// of course, if "unused" is NULL, then "ent" remains as NULL.
	if( ent == NULL )
		ent = unused;

	// (re)allocate entry.
	entry_t *newEnt = CreateEntry( ent, hash, key, keySize, value, valueSize );
	if( newEnt == NULL )
		{
		return false;
		}

	if( bucket->entry == NULL )
		{
		// if "bucket->entry" is NULL,
		// that means "this bucket has no entry".
		// so, allocated entry above is first entry in this bucket.
		bucket->entry = newEnt;
		}
	else if( ent == NULL )
		{
		// "ent is NULL" means
		// no duplicated key entry and unused entry found at searching.
		// so we have new entry(allocated entry).
		// and this bucket has one or more entry, so
		// * "prev" must not be NULL,
		// * "prev" is last entry in this bucket unti we add new entry.
		//   so, "prev->next" must be NULL.
		// * "unused" must be NULL.
		assert( prev != NULL );
		assert( prev->next == NULL );
		assert( unused == NULL );
		
		// append new entry to the tail.
		prev->next = newEnt;
		}
	
	// else, if we haven't much any above condition,
	// we have overwrited dupulicated key entry or reused unused entry.
	
	return true;
	}
Пример #22
0
TEST(MapsTest, file_buffer_cross) {
  constexpr size_t kBufferSize = 2048;
  TemporaryFile tf;
  ASSERT_TRUE(tf.fd != -1);

  // Compute how many to add in the first buffer.
  size_t entry_len = CreateEntry(0).size();
  size_t index;
  std::string file_data;
  for (index = 0; index < kBufferSize / entry_len; index++) {
    file_data += CreateEntry(index);
  }
  // Add a long name to make sure that the first buffer does not contain a
  // complete line.
  // Remove the last newline.
  size_t extra = 0;
  size_t leftover = kBufferSize % entry_len;
  size_t overlap1_index = 0;
  std::string overlap1_name;
  if (leftover == 0) {
    // Exact match, add a long name to cross over the value.
    overlap1_name = "/fake/name/is/long/on/purpose";
    file_data.erase(file_data.size() - 1);
    file_data += ' ' + overlap1_name + '\n';
    extra = entry_len + overlap1_name.size() + 1;
    overlap1_index = index;
  }

  // Compute how many need to go in to hit the buffer boundary exactly.
  size_t bytes_left_in_buffer = kBufferSize - extra;
  size_t entries_to_add = bytes_left_in_buffer / entry_len + index;
  for (; index < entries_to_add; index++) {
    file_data += CreateEntry(index);
  }

  // Now figure out how many bytes to add to get exactly to the buffer boundary.
  leftover = bytes_left_in_buffer % entry_len;
  std::string overlap2_name;
  size_t overlap2_index = 0;
  if (leftover != 0) {
    file_data.erase(file_data.size() - 1);
    file_data += ' ';
    overlap2_name = std::string(leftover - 1, 'x');
    file_data += overlap2_name + '\n';
    overlap2_index = index - 1;
  }

  // Now add a few entries on the next page.
  for (size_t start = index; index < start + 10; index++) {
    file_data += CreateEntry(index);
  }

  ASSERT_TRUE(android::base::WriteStringToFile(file_data, tf.path, 0660, getuid(), getgid()));

  FileMaps maps(tf.path);
  ASSERT_TRUE(maps.Parse());
  EXPECT_EQ(index, maps.Total());
  // Verify all of the maps.
  for (size_t i = 0; i < index; i++) {
    MapInfo* info = maps.Get(i);
    ASSERT_TRUE(info != nullptr) << "Failed verifying index " + std::to_string(i);
    EXPECT_EQ(i * 4096, info->start) << "Failed verifying index " + std::to_string(i);
    EXPECT_EQ((i + 1) * 4096, info->end) << "Failed verifying index " + std::to_string(i);
    EXPECT_EQ(0U, info->offset) << "Failed verifying index " + std::to_string(i);
    if (overlap1_index != 0 && i == overlap1_index) {
      EXPECT_EQ(overlap1_name, info->name) << "Failed verifying overlap1 name " + std::to_string(i);
    } else if (overlap2_index != 0 && i == overlap2_index) {
      EXPECT_EQ(overlap2_name, info->name) << "Failed verifying overlap2 name " + std::to_string(i);
    } else {
      EXPECT_EQ("", info->name) << "Failed verifying index " + std::to_string(i);
    }
  }
}
Пример #23
0
void AddItemToObject(JSON *object, const char *key, JSON *value){
    JSON *it = object->son;
    JSON *entry = CreateEntry(key, value);
    AddEntryToObject(object, entry);
}
Пример #24
0
/**
Creates a new entry as a child of the current context.

The parent ID and entry ID are set by the Message Server.

@param	aEntry
Index entry value for the new entry

@return
KErrNone - success; KErrNoMemory - a memory allocation failed;
KErrNotSupported - aEntry is invalid
*/
EXPORT_C TInt CMsvServerEntry::CreateEntry(TMsvEntry& aEntry)
	{
	return CreateEntry(aEntry, KMsvServerId);
	}
Пример #25
0
/**
Creates a new entry as a child of the current context as part of a
bulk creation operation

The parent ID and entry ID are set by the Message Server.

@param	aEntry
Index entry value for the new entry

@return
KErrNone - success; KErrNoMemory - a memory allocation failed;
KErrNotSupported - aEntry is invalid
*/
EXPORT_C TInt CMsvServerEntry::CreateEntryBulk(TMsvEntry& aEntry)
	{
	return CreateEntry(aEntry, KMsvServerId, ETrue);
	}