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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Name        : grp_funcs.cpp

// Part of     : libc-db specific cpp file

// This is a project specific include file for building the 

// group database related functions as part of libc library.

// Version     : 1.0

//

#include <grp.h>

#include <errno.h>

#include <pthread.h>

#include <stdlib.h>

#include <string.h>

#include "libc_private.h"

#if (defined(__SYMBIAN32__) && (defined(__WINSCW__) || defined(__WINS__)))

#include "libc_wsd_defs.h"

#endif

#ifndef EMULATOR

static pthread_mutex_t getgrent_mutex = PTHREAD_MUTEX_INITIALIZER;

int isfirstgrent=1;

#else //EMULATOR

GET_STATIC_VAR_FROM_TLS(getgrent_mutex, pthread_mutex_t)

GET_GLOBAL_VAR_FROM_TLS(isfirstgrent, int)

#define getgrent_mutex (*GET_WSD_VAR_NAME(getgrent_mutex, s)())

#define isfirstgrent	    (*GET_WSD_VAR_NAME(isfirstgrent, g)())

#endif //EMULATOR

extern "C" {

//Returns the pointer to the filled struct group with the 

//values corresponding to the group id gid

//We simulate only the possibility of having a single user in a single group 

//as the OS does not support the multiuser and multigroup concept as in typical

//unix systems.Hence we set default values as in "root" mode in unix.

EXPORT_C struct group *getgrgid(gid_t gid)

{

	struct group* res;

	struct group* tempresult;

	//The library has to return a filled pointer to struct hence we are forced to malloc

	res = (struct group*)malloc (sizeof (struct group));

	if(res == NULL){

		errno = ENOMEM;

		return NULL;

	}

	res->gr_mem = (char**)malloc (sizeof (char**));

	if(res->gr_mem == NULL){

		errno = ENOMEM;

		free(res);

		return NULL;

	}

	//We call getgrgid_r to fill the result structure

	int retval = getgrgid_r (gid, res, NULL, 0, &tempresult);

	if(retval != 0){

		//Since the library doesn't fill the struct group,its responsible for freeing them

		free (res->gr_mem);

		free (res);

		//errno is set by getgrgid_r itself in this case

		errno = retval;

		return NULL;

	}

	return res;

}

//Fills a valid grp with the values corresponding to the group id gid

//and ensures the *result points to this value

//We simulate only the possibility of having a single user in a single group 

//as the OS does not support the multiuser and multigroup concept as in typical

//unix systems.Hence we set default values as in "root" mode in unix.

EXPORT_C int getgrgid_r(gid_t gid, struct group *grp, char* /*buffer*/,size_t /*bufsize*/, struct group **result)

{

	if(gid != 0){

		errno = ENOENT;

		*result = NULL;

		return errno;

	}

	//Setting values corresponding to a single user systems

	grp->gr_name = "root";

	grp->gr_passwd = NULL;

	grp->gr_gid = gid;

	grp->gr_mem[0] = "root";

	*result = grp;

	errno = 0;

	return 0;

}

//Returns the pointer to the filled struct group with the 

//values corresponding to the group name

//We simulate only the possibility of having a single user in a single group 

//as the OS does not support the multiuser and multigroup concept as in typical

//unix systems.Hence we set default values as in "root" mode in unix.

EXPORT_C struct group *getgrnam(const char* name)

{

	struct group* res;

	struct group* tempresult;

	//The library has to return a filled pointer to struct hence we are forced to malloc

	res = (struct group*)malloc (sizeof (struct group));

	if(res == NULL){

		errno = ENOMEM;

		return NULL;

	}

	res->gr_mem = (char**)malloc (sizeof (char**));

	if(res->gr_mem == NULL){

		errno = ENOMEM;

		free(res);

		return NULL;

	}

	//We call getgrnam_r to fill the result structure

	int retval = getgrnam_r (name, res, NULL, 0, &tempresult);

	if(retval != 0){

		//Since we dont return a filled struct,we are responsible for freeing it

		free (res->gr_mem);

		free (res);

		//errno is set by getgrnam_r

		errno = retval;

		return NULL;

	}

	return res;

}

//Fills a valid grp with the values corresponding to the group name

//and ensures the *result points to this value

//We simulate only the possibility of having a single user in a single group 

//as the OS does not support the multiuser and multigroup concept as in typical

//unix systems.Hence we set default values as in "root" mode in unix.

EXPORT_C int getgrnam_r(const char *name, struct group *grp, char* /*buffer*/,size_t /*bufsize*/, struct group **result)

{

	if(strcmp (name, "root")){

		errno = ENOENT;

		*result = NULL;

		return errno;

	}

	//Setting values corresponding to single user system

	grp->gr_name = "root";

	grp->gr_passwd = NULL;

	grp->gr_gid = 0;

	grp->gr_mem[0] = "root";

	*result = grp;

	errno = 0;

	return 0;

}

//On repeated calls returns pointer to the group struct corresponding to 

//entries in group database,but since we dont support a user group concept

//we return a pointer to a filled struct group just the first time the application

//calls it and subsequent calls return NULL indicating an end of the database file

//The isfirstgrent variable is used to track the call on this api

EXPORT_C struct group *getgrent(void){

	struct group *gr;

	pthread_mutex_lock(&getgrent_mutex);

	if(isfirstgrent){

		gr = getgrgid (0);

		isfirstgrent = 0;

	}

	else{

		gr = NULL;

	}

	pthread_mutex_unlock(&getgrent_mutex);

	return gr;

}

//On repeated calls sets the pointer reading the group database,to the first entry

//but since we dont support a user group concept,we return a success each time it is called

//as if it points to the first entry in the database

//The isfirstgrent variable is used to track the call on this api

EXPORT_C int setgrent(void){

	pthread_mutex_lock(&getgrent_mutex);

	if(!isfirstgrent)

		isfirstgrent = 1;

	pthread_mutex_unlock(&getgrent_mutex);

	return 0;

}

//On repeated calls sets the read pointer to the end of the group database,

//but since we dont support a user group concept,we simply return

//as if it points to the last entry in the database

//The isfirstgrent variable is used to track the call on this api

EXPORT_C void endgrent(void){

	pthread_mutex_lock(&getgrent_mutex);

	if(!isfirstgrent)

		isfirstgrent = 0;

	pthread_mutex_unlock(&getgrent_mutex);

	return;

}

//Resets the group database with entries in ngroups for n users,

//but since the OS doesnt support this concept,we simply return 0

EXPORT_C int setgroups(int /*n*/, const gid_t* /*ngroups*/){

	return 0;

}

} // extern "C"