Пример #1
0
char db_createUser( const char *username, const char *password )
{
	int userId, userLen, passLen;	
	User_t *user;
   	unsigned char hashpass[ SHA256_LEN ];
		
	userId = 0;
	userLen = strlen( username );
	passLen = strlen( password );
	memset( hashpass, 0, sizeof( hashpass ) );

	if( userLen < 1 || userLen > USER_MAX || passLen < 1 || passLen > SHA256_LEN )
		return DB_ERR_CREATE_LENGTH;
	
	if( userExists( username ) )
		return DB_ERR_CREATE_EXISTS;

	db_hashPass( password, hashpass );

	userId = getNextID();
	user = malloc( sizeof( User_t ) );
	memset( user, 0, sizeof( User_t ) );
	user->userId = userId;
	memcpy( user->username, username, strlen( username ) );
	memcpy( user->userpass, hashpass, SHA256_LEN );
	user->flags = 0;
	addUser( user );
	free( user );
		
	return DB_CREATE;
}
Пример #2
0
void LLXferManager::requestFile(const std::string& remote_filename,
								ELLPath remote_path,
								const LLHost& remote_host,
								BOOL delete_remote_on_completion,
								void (*callback)(void*,S32,void**,S32,LLExtStat),
								void** user_data,
								BOOL is_priority)
{
	LLXfer *xferp;

	xferp = (LLXfer *) new LLXfer_Mem();
	if (xferp)
	{
		addToList(xferp, mReceiveList, is_priority);
		((LLXfer_Mem *)xferp)->initializeRequest(getNextID(),
												 remote_filename, 
												 remote_path,
												 remote_host,
												 delete_remote_on_completion,
												 callback, user_data);
		startPendingDownloads();
	}
	else
	{
		llerrs << "Xfer allocation error" << llendl;
	}
}
Пример #3
0
  void System::onRawArrival( HANDLE handle )
  {
    UINT pathLength = 0;

    if ( GetRawInputDeviceInfoW( handle, RIDI_DEVICENAME, NULL, &pathLength ) )
      NIL_EXCEPT_WINAPI( "GetRawInputDeviceInfoW failed" );

    wideString rawPath( pathLength, '\0' );

    GetRawInputDeviceInfoW( handle, RIDI_DEVICENAME, &rawPath[0], &pathLength );
    rawPath.resize( rawPath.length() - 1 );

    for ( auto device : mDevices )
    {
      if ( device->getHandler() != Device::Handler_RawInput )
        continue;

      auto rawDevice = static_cast<RawInputDevice*>( device );

      if ( !_wcsicmp( rawDevice->getRawPath().c_str(), rawPath.c_str() ) )
      {
        deviceConnect( rawDevice );
        return;
      }
    }

    auto device = new RawInputDevice( this, getNextID(), handle, rawPath );

    if ( isInitializing() )
      device->setStatus( Device::Status_Connected );
    else
      deviceConnect( device );

    mDevices.push_back( device );
  }
Пример #4
0
//=============================================================================
// Write the current values into the database.
//=============================================================================
QString CAddress::saveChanges ()
{
  QString 	      intro, firstValue, where, newid;
  unsigned int    row;

  //----------------------------------------------------------------------------
  // If nothing was changed, nothing has to be done.
  //----------------------------------------------------------------------------
  if (!mContentChanged)
    return mCurrent;
  
  for (row = 0; row < mAddress.count(); row++)
  {
    if (!mAddress.at(row)->hasChanged())
      continue;
    
    //--------------------------------------------------------------------------
    // Build the SQL statement.
    //--------------------------------------------------------------------------
    if (row < mIDs.count())
    {
      intro      = "UPDATE contacts_addresses (";
      firstValue = "";
      where      = "WHERE address_id = " + mIDs[row];
    }
    else
    {
      newid      = getNextID();
      mIDs      << newid;
      
      intro      = "INSERT contacts_addresses (address_id, ";
      firstValue = newid + ", ";
      where      = "";
    }
    
    //--------------------------------------------------------------------------
    // Execute the SQL statement.
    //--------------------------------------------------------------------------
    QSqlQuery query (intro + "person_id, type, street, zip, city, state, country, "
                     "last_modified) VALUES (" + firstValue + mCurrent +  ", " + 
                     QString::number (mAddress.at(row)->type()) + ", '" + 
                     mAddress.at(row)->street() + "', '" +
                     mAddress.at(row)->zip() + "', '" + 
                     mAddress.at(row)->city() + "', '" + 
                     mAddress.at(row)->state() + "', '" + 
                     mAddress.at(row)->country() + "', TIMESTAMP) " + where);
    
    if (!query.isActive())
    {
      SHOW_DB_ERROR(tr ("Error during writing of data"), query);
      return "";
    }

  }

  mContentChanged = false;
  mNew            = false;

  return mCurrent;
}
Пример #5
0
U64 LLXferManager::registerXfer(const void *datap, const S32 length)
{
	LLXfer *xferp;
	U64 xfer_id = getNextID();

	xferp = (LLXfer *) new LLXfer_Mem();
	if (xferp)
	{
		xferp->mNext = mSendList;
		mSendList = xferp;

		xfer_id = ((LLXfer_Mem *)xferp)->registerXfer(xfer_id, datap,length);

		if (!xfer_id)
		{
			removeXfer(xferp,&mSendList);
		}
	}
	else
	{
		llerrs << "Xfer allocation error" << llendl;
		xfer_id = 0;
	}	

    return(xfer_id);
}
Пример #6
0
Entity* EntityManager::createEntity()
{
    EntityID id = getNextID();
    Entity* entity = new Entity();
    entity->id = id;
    entities.push_back(*entity);
    return entity;
}
Пример #7
0
int Manager::createAccount(const std::string &accountName, const double startValue, const Time &time)
{
    const int newID = getNextID();
    Account *newAccount = new Account(newID, accountName, startValue, time);
    account.push_back(newAccount);
    amountAccounts++;
    ID.push_back(newID);
    return newID;
}
Пример #8
0
Neithal::Neithal(Inventory* p, int stack) : Resource(p){
	setName("Neithal");
	setWeight(float(0.1));
	setSymbol(new Symbol('*', 1));
	setItemID(getNextID());
	setStack(stack);
	totWeight = getWeight()*stack;
	setResourceType(neithal);
}
Пример #9
0
Iron::Iron(Inventory* p, int stack) : Resource(p){
	setName("Iron");
	setWeight(float(0.5));
	setSymbol(new Symbol('*', 8));
	setItemID(getNextID());
	setStack(stack);
	totWeight = getWeight()*stack;
	setResourceType(iron);
}
Пример #10
0
Wood::Wood(Inventory* p, int stack) : Resource(p){
	setName("Wood");
	setWeight(float(0.1));
	setSymbol(new Symbol('*', 6));
	setItemID(getNextID());
	setStack(stack);
	totWeight = getWeight()*stack;
	setResourceType(wood);
}
Пример #11
0
Leather::Leather(Inventory* p, int stack) : Resource(p){
	setName("Leather");
	setWeight(float(0.1));
	setSymbol(new Symbol('*', 14));
	setItemID(getNextID());
	setStack(stack);
	totWeight = getWeight()*stack;
	setResourceType(leather);
}
Пример #12
0
Cloth::Cloth(Inventory* p, int stack) : Resource(p){
	setName("Cloth");
	setWeight(float(0.1));
	setSymbol(new Symbol('*', 7));
	setItemID(getNextID());
	setStack(stack);
	totWeight = getWeight()*stack;
	setResourceType(cloth);
}
Пример #13
0
Selentine::Selentine(Inventory* p, int stack) : Resource(p){
	setName("Selentine");
	setWeight(float(0.1));
	setSymbol(new Symbol('*', 7));
	setItemID(getNextID());
	setStack(stack);
	totWeight = getWeight()*stack;
	setResourceType(selentine);
}
Пример #14
0
void LLXferManager::requestFile(const std::string& local_filename,
								const std::string& remote_filename,
								ELLPath remote_path,
								const LLHost& remote_host,
								BOOL delete_remote_on_completion,
								void (*callback)(void**,S32,LLExtStat),
								void** user_data,
								BOOL is_priority,
								BOOL use_big_packets)
{
	LLXfer *xferp;

	for (xferp = mReceiveList; xferp ; xferp = xferp->mNext)
	{
		if (xferp->getXferTypeTag() == LLXfer::XFER_FILE
			&& (((LLXfer_File*)xferp)->matchesLocalFilename(local_filename))
			&& (((LLXfer_File*)xferp)->matchesRemoteFilename(remote_filename, remote_path))
			&& (remote_host == xferp->mRemoteHost)
			&& (callback == xferp->mCallback)
			&& (user_data == xferp->mCallbackDataHandle))

		{
			// cout << "requested a xfer already in progress" << endl;
			return;
		}
	}

	S32 chunk_size = use_big_packets ? LL_XFER_LARGE_PAYLOAD : -1;
	xferp = (LLXfer *) new LLXfer_File(chunk_size);
	if (xferp)
	{
		addToList(xferp, mReceiveList, is_priority);

		// Remove any file by the same name that happens to be lying
		// around.
		// Note: according to AaronB, this is here to deal with locks on files that were
		// in transit during a crash,
		if(delete_remote_on_completion &&
		   (remote_filename.substr(remote_filename.length()-4) == ".tmp"))
		{
			LLFile::remove(local_filename);
		}
		((LLXfer_File *)xferp)->initializeRequest(
			getNextID(),
			local_filename,
			remote_filename,
			remote_path,
			remote_host,
			delete_remote_on_completion,
			callback,user_data);
		startPendingDownloads();
	}
	else
	{
		llerrs << "Xfer allocation error" << llendl;
	}
}
Пример #15
0
Veilron::Veilron(Inventory* p, int stack) : Resource(p){
	setName("Veilron");
	setWeight(float(0.1));
	setSymbol(new Symbol('*', 0, BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED));
	setItemID(getNextID());
	setStack(stack);
	totWeight = getWeight()*stack;
	setResourceType(veilron);
}
Пример #16
0
Theyril::Theyril(Inventory* p, int stack) : Resource(p){
	setName("Theyril");
	setWeight(float(0.1));
	setSymbol(new Symbol('*', 15));
	setItemID(getNextID());
	setStack(stack);
	totWeight = getWeight()*stack;
	setResourceType(theyril);
}
Пример #17
0
	GameObject::GameObject(   string name, Transform* t , World* scene )
	{
		mScene = scene; 
		this->name = name;
		this->id = getNextID(); 
		t->gameObject = this;
		this->transform = t;

	}
Пример #18
0
 void System::initializeDevices()
 {
   mXInputIDs.resize( XUSER_MAX_COUNT );
   for ( int i = 0; i < XUSER_MAX_COUNT; i++ )
   {
     mXInputIDs[i] = getNextID();
     auto device = new XInputDevice( this, mXInputIDs[i], i );
     mDevices.push_back( device );
   }
 }
ID VectorSysObj::put(SystemObject *systemObject){
	if(shouldExpand())
		expand();
	ID id = getNextID();
	ocupied++;
	vector[id] = systemObject;
	if(id>lastOcupiedID)
		lastOcupiedID = id;
	return id;
}
Пример #20
0
Controller::Player::Player
(
	std::string const & inName,
	Model::Color::Color inColor,
	std::map< Model::Piece::PieceType, std::size_t > const & inMeepleSupply
)
:
	mName( inName ),
	mPlayerID( getNextID() ),
	mColor( inColor ),
	mScore( 0 ),
	mMeepleSupply( inMeepleSupply )
{
}
Пример #21
0
FileID addWord(std::string word, std::fstream& f, bool createIfReauired = true) {
  Block b = getWordBlock(word, f, createIfReauired);
  FileID fid {b.data};

  if (!createIfReauired) return fid;

  if (fid == 0)
    fid = getNextID();

  b.data = fid;
  writeBlockToFile(b, f);

  return fid;
}
Пример #22
0
unsigned OMenu::appendItem(const tstring& text, const Dispatcher::F& f /*nullptr*/, int flags /*0*/) {
	// init structure for new item
	CMenuItemInfo info;
	info.fMask = MIIM_ID | MIIM_TYPE | MIIM_DATA;
	info.fType = MFT_STRING;

	if(flags & FLAG_DISABLED) {
		info.fMask |= MIIM_STATE;
		info.fState |= MFS_DISABLED;
	}
	if (flags & FLAG_DEFAULT && !defaultSet) {
		info.fMask |= MIIM_STATE;
		info.fState |= MFS_DEFAULT;
		defaultSet = true;
	}

	if(flags & FLAG_CHECKED) {
		info.fMask |= MIIM_STATE;
		info.fState |= MFS_CHECKED;
	}

	info.dwTypeData = const_cast< LPTSTR >( text.c_str() );
	const auto index = GetMenuItemCount();

	info.wID = getNextID();

	if(f) {
		OMenuItem* mi = new OMenuItem();
		mi->ownerdrawn = false;
		if (flags & FLAG_THREADED) {
			mi->f = [=] { MainFrame::getMainFrame()->addThreadedTask(f); };
		} else {
			mi->f = f;
		}

		//mi->f = (flags & FLAG_THREADED) ? [=] { MainFrame::getMainFrame()->addThreadedTask(f); } : f;
		mi->text = text;
		mi->parent = this;

		addItem(mi);

		info.dwItemData = reinterpret_cast<ULONG_PTR>(mi);
	}

	CMenu::InsertMenuItem(index, TRUE, &info);
	return index;
}
Пример #23
0
void LLXferManager::requestVFile(const LLUUID& local_id,
								 const LLUUID& remote_id,
								 LLAssetType::EType type, LLVFS* vfs,
								 const LLHost& remote_host,
								 void (*callback)(void**,S32,LLExtStat),
								 void** user_data,
								 BOOL is_priority)
{
	LLXfer *xferp;

	for (xferp = mReceiveList; xferp ; xferp = xferp->mNext)
	{
		if (xferp->getXferTypeTag() == LLXfer::XFER_VFILE
			&& (((LLXfer_VFile*)xferp)->matchesLocalFile(local_id, type))
			&& (((LLXfer_VFile*)xferp)->matchesRemoteFile(remote_id, type))
			&& (remote_host == xferp->mRemoteHost)
			&& (callback == xferp->mCallback)
			&& (user_data == xferp->mCallbackDataHandle))

		{
			// cout << "requested a xfer already in progress" << endl;
			return;
		}
	}

	xferp = (LLXfer *) new LLXfer_VFile();
	if (xferp)
	{
		addToList(xferp, mReceiveList, is_priority);
		((LLXfer_VFile *)xferp)->initializeRequest(getNextID(),
			vfs,
			local_id,
			remote_id,
			type,
			remote_host,
			callback,
			user_data);
		startPendingDownloads();
	}
	else
	{
		llerrs << "Xfer allocation error" << llendl;
	}

}
Пример #24
0
  BOOL CALLBACK System::diDeviceEnumCallback( LPCDIDEVICEINSTANCEW instance,
  LPVOID referer )
  {
    auto system = reinterpret_cast<System*>( referer );

    for ( auto identifier : system->mXInputDeviceIDs )
      if ( instance->guidProduct.Data1 == identifier )
        return DIENUM_CONTINUE;

    for ( auto device : system->mDevices )
    {
      if ( device->getHandler() != Device::Handler_DirectInput )
        continue;

      auto diDevice = static_cast<DirectInputDevice*>( device );

      if ( diDevice->getInstanceID() == instance->guidInstance )
      {
        if ( device->getSavedStatus() == Device::Status_Disconnected )
          system->deviceConnect( device );
        else
          device->setStatus( Device::Status_Connected );

        return DIENUM_CONTINUE;
      }
    }

    Device* device = new DirectInputDevice( system, system->getNextID(), instance );

    if ( system->isInitializing() )
      device->setStatus( Device::Status_Connected );
    else
      system->deviceConnect( device );

    system->mDevices.push_back( device );

    return DIENUM_CONTINUE;
  }
Пример #25
0
void
CArchTaskBarWindows::addReceiver(IArchTaskBarReceiver* receiver)
{
	// ignore bogus receiver
	if (receiver == NULL) {
		return;
	}

	// add receiver if necessary
	CReceiverToInfoMap::iterator index = m_receivers.find(receiver);
	if (index == m_receivers.end()) {
		// add it, creating a new message ID for it
		CReceiverInfo info;
		info.m_id = getNextID();
		index = m_receivers.insert(std::make_pair(receiver, info)).first;

		// add ID to receiver mapping
		m_idTable.insert(std::make_pair(info.m_id, index));
	}

	// add receiver
	PostMessage(m_hwnd, kAddReceiver, index->second.m_id, 0);
}
Пример #26
0
void CRtTable::addRecord(const QVariantList& values)
{
	// 按顺序添加记录到表中,分析各字段的数据类型,然后根据类型解析值,放到数据库中
	
	if (m_fields.count() == values.count())
	{
		QString strSQL ;
		strSQL = "INSERT INTO ";
		strSQL += m_tb_descr.table_name;
		strSQL += "(";
		strSQL += m_strfield;
		strSQL += ") VALUES(";
		QSqlQuery query(m_db);
		for (int i = 0 ; i < m_fields.count() ;i++)
		{
			const FIELD_PARA_STRU& stField = m_fields[i];

			// 添加KEYID
			if (i == 0)
			{
				int keyid = getNextID();
				strSQL += QString::number(keyid);
				strSQL += ",";
				continue;
			}
			strSQL += getSqlValue(stField.data_type,values[i]);			
			if (i < m_fields.count() -1)
			{
				strSQL +=  ",";
			}
		}
		strSQL += ")";
		query.exec(strSQL);

		updateNextID();
	}
}
Пример #27
0
void GLRenderer::startMesh(int* id)
{
	*id = getNextID();
	activeID = *id;
	activeMesh.translation = glm::vec3(0,0,0);
}
Пример #28
0
polygon_id NavMesh::addPolygon(NavPoly& p) {
	p.id = getNextID();
	p.parent = this;
	polygon.push_back(p);
	return p.id;
}
Пример #29
0
Text& TextSet::addNew(){
	Text t(getNextID());
	add(t);
	return get(t.getId());
}