// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32utils\setcap\main.cpp

// SETCAP.EXE

// Makes a copy of an executable file and gives it the specified capabilities.

// It may also, optionally, modify the Secure or Vendor IDs.

// This runs under the Symbian OS - it is not a native PC utility.

// Command line syntax:

// SETCAP source_exe capability [-SID secureId] [-VID vendorId] [destination_path]

// source_exe         Name and path of an executable file (default path is Z:\SYS\BIN\)

// capability         Hexadecimal value for capabilities

// secureId			 Optional hexadecimal value of secure ID

// vendorId			 Optional hexadecimal value of vendor ID

// destination_path   Optional name and path to copy the exe to

// (defaults to C:\SYS\BIN\source_exe_name)

// Notes

// 1.  The 'capability' command line argument is the hexadecimal value of the

// capabilities when they are represented as a bit-field. E.g. the 3 capabilities

// LocalServices, ReadUserData and WriteUserData would together have a value of:

// (1<<ECapabilityLocalServices) | (<<ECapabilityReadUserData) | (1<<ECapabilityWriteUserData)

// Which in hexadecimal is '1c000'

// If the value supplied includes capabilities which aren't supported by the current

// OS version, then these are ignored and not added to the file.

// 2.  If the source executable is in ROM it must be a RAM executable image, not an

// execute-in-place image. I.e. its entry in an OBY file must start with "data=" and

// not "file=".

// For OBY files generated automatically by "ABLD ROMFILE" this needs to be achieved by

// using lines similar to the following in the executables MMP file:

// ROMTARGET    // Empty ROM path means don't include normal execute-in-place file

// RAMTARGET \sys\bin\    // Target path (in ROM) for RAM executable image

// 3.  The Symbian OS only allows one binary file with a given name; the name doesn't

// include file path or extension. This means if SETCAP is used to make a copy of a

// binary which is already loaded then the copy will not get loaded when used with

// RProcess::Create(), instead the already loaded version will be used. To avoid this,

// use SETCAP to give the copy a different name. E.g. "SETCAP test.exe 1234 test2.exe"

// 

//

/**

 @file

*/

#include "setcap.h"

#include <f32file.h>

TParse SourceName;

TParse DestinationName;

RFs Fs;

#ifdef __WINS__

TInt DoIt()

	{

	TInt  r;

	TBuf<MAX_PATH> sName;

	r = MapEmulatedFileName(sName, SourceName.NameAndExt());

	if(r!=KErrNone)

		return r;

	TBuf<MAX_PATH> dName;

	r = MapEmulatedFileName(dName, DestinationName.FullName());

	if(r!=KErrNone)

		return r;

	if(!Emulator::CopyFile((LPCTSTR)sName.PtrZ(),(LPCTSTR)dName.PtrZ(),FALSE))

		return KErrGeneral;

	HANDLE hFile=Emulator::CreateFile((LPCTSTR)dName.PtrZ(),GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,NULL);

	if (hFile==INVALID_HANDLE_VALUE)

		return KErrArgument;

	return SetCap(hFile);

	}

#else // Not WINS

#include <f32file.h>

RFile Source;

RFile Destination;

TInt DoIt()

	{

	TInt r;

	r=Source.Open(Fs,SourceName.FullName(),EFileRead);

	if(r!=KErrNone)

		return r;

	r = Destination.Replace(Fs,DestinationName.FullName(),EFileWrite);

	if(r!=KErrNone)

		return r;

	TUint8* buffer;

	const TInt KBufferSize = 0x10000;

	buffer = (TUint8*)User::Alloc(KBufferSize);

	if(!buffer)

		return KErrNoMemory;

	TPtr8 p(buffer,KBufferSize,KBufferSize);

	TInt n = 0;

	while (r==KErrNone)

		{

		r = Source.Read(p);

		if(r!=KErrNone || p.Size()==0)

			break;

		if (n==0)

			{

			// first block contains header

			if ((TUint)p.Size() < sizeof(E32ImageHeader))

				{

				r = KErrCorrupt;

				break;

				}

			E32ImageHeader* h = (E32ImageHeader*)buffer;

			r = SetCap(h);

			}

		if (r==KErrNone)

			r = Destination.Write(p);

		++n;

		}

	delete buffer;

	Source.Close();

	Destination.Close();

	return r;

	}

#endif

_LIT(KDefaultSourcePath,"z:\\sys\\bin\\");

_LIT(KDefaultDestinationPath,"?:\\sys\\bin\\");

_LIT(KSIDOption,"-SID");

_LIT(KVIDOption,"-VID");

TInt ParseCommandLine()

	{

	TBuf<256> c;

	User::CommandLine(c);

	// Get exe name

	TLex l(c);

	if(SourceName.SetNoWild(l.NextToken(),0,&KDefaultSourcePath)!=KErrNone)

		return KErrArgument;

	// Get capability

	TLex cl(l.NextToken());

	if(cl.Val((TInt64&)Capability,EHex)!=KErrNone)

		return KErrArgument;

	// Mask out unsupported capabilities

	TCapabilitySet all;

	all.SetAllSupported();

	((TCapabilitySet&)Capability).Intersection(all);

	// We always update capabilities in the headers

	CapabilitySet = ETrue;

	// Get options

	SecureIdSet = EFalse;

	VendorIdSet = EFalse;

	TPtrC nextToken;

	for (;;)

		{

		nextToken.Set(l.NextToken());

		if (nextToken == KSIDOption)

			{

			// SID specified

			nextToken.Set(l.NextToken());

			if (nextToken == KNullDesC)

				return KErrArgument;				

			TLex sl(nextToken);

			if(sl.Val(SecureId.iId,EHex)!=KErrNone)

				return KErrArgument;

			SecureIdSet = ETrue;

			}

		else if (nextToken == KVIDOption)

			{

			// VID specified

			nextToken.Set(l.NextToken());

			if (nextToken == KNullDesC)

				return KErrArgument;				

			TLex sl(nextToken);

			if(sl.Val(VendorId.iId,EHex)!=KErrNone)

				return KErrArgument;

			VendorIdSet = ETrue;

			}

		else

			break;

		}

	// Get target path

	TPtrC s(SourceName.NameAndExt());

	TBuf<sizeof(KDefaultDestinationPath)> defaultDestinationPath(KDefaultDestinationPath);

	defaultDestinationPath[0] = (TUint8) RFs::GetSystemDriveChar();

	if(DestinationName.SetNoWild(nextToken,&s,&defaultDestinationPath)!=KErrNone)

		return KErrArgument;

	// Check we used all the arguments

	if (l.NextToken() != KNullDesC)

		return KErrArgument;

	return KErrNone;

	}

TInt E32Main()

	{

	TInt r;

	 // Turn off lazy dll unloading

	RLoader l;

	if ((r=l.Connect())!=KErrNone)

		return r;

	r = l.CancelLazyDllUnload();

	l.Close();

	if (r!=KErrNone)

		return r;

	r = ParseCommandLine();

	if(r!=KErrNone)

		return r;

	r = Fs.Connect();

	if(r!=KErrNone)

		return r;

	r = Fs.MkDirAll(DestinationName.FullName());

	if(r==KErrNone || r==KErrAlreadyExists)

		r = DoIt();

	Fs.Close();

	return r;

	}