/* Remove an affected_type structure from a char (called when duration
reaches zero). Pointer *af must never be NIL! Frees mem and calls
affect_location_apply */
void affect_remove( struct char_data *ch, struct affected_type *af )
{
struct affected_type *hjp;
if (!ch->affected) {
logE("affect removed from char without affect");
logE(GET_NAME(ch));
return;
}
affect_modify(ch, af->location, (int) af->modifier,
af->bitvector, FALSE);
/* remove structure *af from linked list */
if (ch->affected == af) {
/* remove head of list */
ch->affected = af->next;
} else {
for(hjp = ch->affected; (hjp->next) && (hjp->next != af); hjp = hjp->next);
if (hjp->next != af) {
logE("Could not locate affected_type in ch->affected. (handler.c, affect_remove)");
return;
}
hjp->next = af->next; /* skip the af element */
}
free ( af );
affect_total(ch);
}
/* remove an object from an object */
void obj_from_obj(struct obj_data *obj)
{
struct obj_data *tmp, *obj_from;
char buf[100];
if (obj->carried_by) {
sprintf(buf, "%s carried by %s in obj_from_obj\n", obj->name,
obj->carried_by->player.name);
logE(buf);
}
if (obj->equipped_by) {
sprintf(buf, "%s equipped by %s in obj_from_obj\n", obj->name,
obj->equipped_by->player.name);
logE(buf);
}
if (obj->in_room != NOWHERE) {
sprintf(buf, "%s in room %d in obj_from_obj\n", obj->name,
obj->in_room);
logE(buf);
}
assert(!obj->carried_by && !obj->equipped_by && obj->in_room == NOWHERE);
if (obj->in_obj) {
obj_from = obj->in_obj;
if (obj == obj_from->contains) /* head of list */
obj_from->contains = obj->next_content;
else {
for (tmp = obj_from->contains;
tmp && (tmp->next_content != obj);
tmp = tmp->next_content); /* locate previous */
if (!tmp) {
perror("Fatal error in object structures.");
assert(0);
}
tmp->next_content = obj->next_content;
}
/* Subtract weight from containers container */
for(tmp = obj->in_obj; tmp->in_obj; tmp = tmp->in_obj)
GET_OBJ_WEIGHT(tmp) -= GET_OBJ_WEIGHT(obj);
GET_OBJ_WEIGHT(tmp) -= GET_OBJ_WEIGHT(obj);
/* Subtract weight from char that carries the object */
if (tmp->carried_by)
IS_CARRYING_W(tmp->carried_by) -= GET_OBJ_WEIGHT(obj);
obj->in_obj = 0;
obj->next_content = 0;
} else {
perror("Trying to object from object when in no object.");
assert(0);
}
if(obj_from->in_room != NOWHERE)
if(IS_SET(real_roomp(obj_from->in_room)->room_flags, SAVE_ROOM))
save_room(obj_from->in_room);
}
/**
* find the count most near the time, and before it
* count is start in zero
*/
long findPowerDataCountByTime(long long time, PowerDataSet *set)
{
long begin, end, mid, ret;
PowerData * data_begin, *data_end, *data_mid;
begin = 0;
end = getPowerSetNum(set) - 1;
data_begin = getPowerData(set, begin);
data_end = getPowerData(set, end);
if (time < data_begin->time || time > data_end->time) {
logE("time is out range");
return -1;
}
while (begin < end) {
mid = (begin + end) / 2;
data_mid = getPowerData(set, mid);
if (data_mid->time < time) {
begin = mid + 1;
} else if (data_mid->time > time) {
end = mid - 1;
} else {
ret = mid;
break;
}
}
if (begin == end) {
ret = begin < mid ? begin : mid;
}
return ret;
}
MINT32 default_flashlight_ioctl(unsigned int cmd, unsigned long arg) {
int i4RetValue = 0;
int iFlashType = (int)FLASHLIGHT_NONE;
kdStrobeDrvArg kdArg;
unsigned long copyRet;
copyRet = copy_from_user(&kdArg , (void *)arg , sizeof(kdStrobeDrvArg));
switch(cmd)
{
case FLASHLIGHTIOC_G_FLASHTYPE:
iFlashType = FLASHLIGHT_NONE;
kdArg.arg = iFlashType;
if(copy_to_user((void __user *) arg , (void*)&kdArg , sizeof(kdStrobeDrvArg)))
{
logE("[FLASHLIGHTIOC_G_FLASHTYPE] ioctl copy to user failed ~");
return -EFAULT;
}
break;
default :
logI("[default_flashlight_ioctl] ~");
break;
}
return i4RetValue;
}
static void handleSerialEvent(struct VeSerialPortS *port, VeSerialEvent event, char const *descr)
{
if (event == VE_SERIAL_EV_ERROR) {
logE("serial", "%s, bailing out", descr);
pltExit(1);
}
}
int getStrobeIndex(int strobeId)
{
if(strobeId<1 || strobeId>2)
{
logE("strobeId=%d is wrong",strobeId);
return -1;
}
return strobeId-1;
}
int getPartIndex(int partId)
{
if(partId<1 || partId>2)
{
logE("partId=%d is wrong",partId);
return -1;
}
return partId-1;
}
/* move a player out of a room */
void char_from_room(struct char_data *ch)
{
char buf[MAX_INPUT_LENGTH];
struct char_data *i;
struct room_data *rp;
if (ch->in_room == NOWHERE) {
logE("NOWHERE extracting char from room (handler.c, char_from_room)");
return;
}
if (ch->equipment[WEAR_LIGHT])
if (ch->equipment[WEAR_LIGHT]->obj_flags.type_flag == ITEM_LIGHT)
if (ch->equipment[WEAR_LIGHT]->obj_flags.value[2]) /* Light is ON */
real_roomp(ch->in_room)->light--;
rp = real_roomp(ch->in_room);
if (rp==NULL) {
sprintf(buf, "ERROR: char_from_room: %s was not in a valid room (%d)",
(!IS_NPC(ch) ? (ch)->player.name : (ch)->player.short_descr),
ch->in_room);
logE(buf);
return;
}
if (ch == rp->people) /* head of list */
rp->people = ch->next_in_room;
else { /* locate the previous element */
for (i = rp->people; i && i->next_in_room != ch; i = i->next_in_room)
;
if (i)
i->next_in_room = ch->next_in_room;
else {
sprintf(buf, "SHIT, %s was not in people list of his room %d!",
(!IS_NPC(ch) ? (ch)->player.name : (ch)->player.short_descr),
ch->in_room);
logE(buf);
}
}
ch->in_room = NOWHERE;
ch->next_in_room = 0;
}
void addPowerDataGroup(PowerDataGroup * group, PowerData * data)
{
if (group == NULL || data == NULL) {
logE("addPowerDataGroup : group or data is null");
return;
}
group->datas[group->size] = *data;
group->size++;
}
/** 50ms tick to invalidate items if there are not received in time */
void valuesTick(void)
{
gpsTick();
veItemTick(&root);
if (timeout && --timeout == 0) {
logE(MODULE, "timeout connecting device");
pltExit(129);
}
}
int getSensorDevIndex(int sensorDev)
{
if(sensorDev==e_CAMERA_MAIN_SENSOR)
return 0;
else if(sensorDev==e_CAMERA_SUB_SENSOR)
return 1;
else if(sensorDev==e_CAMERA_MAIN_2_SENSOR)
return 2;
else
{
logE("sensorDev=%d is wrong",sensorDev);
return -1;
}
}
/* Puts object in store, at first item which has no -1 */
void put_obj_in_store(struct obj_data *obj, struct obj_file_u *st)
{
int j;
struct obj_file_elem *oe;
char buf[256];
if (st->number>=MAX_OBJ_SAVE) {
printf("holy shit, you want to rent more than %d items?!\n", st->number);
return;
}
oe = st->objects + st->number;
oe->item_number = obj_index[obj->item_number].virtual;
oe->value[0] = obj->obj_flags.value[0];
oe->value[1] = obj->obj_flags.value[1];
oe->value[2] = obj->obj_flags.value[2];
oe->value[3] = obj->obj_flags.value[3];
oe->extra_flags = obj->obj_flags.extra_flags;
oe->weight = obj->obj_flags.weight;
oe->timer = obj->obj_flags.timer;
oe->bitvector = obj->obj_flags.bitvector;
/* new, saving names and descrips stuff */
if (obj->name)
strcpy(oe->name, obj->name);
else {
sprintf(buf, "object %d has no name!", obj_index[obj->item_number].virtual);
logE(buf);
}
if (obj->short_description)
strcpy(oe->sd, obj->short_description);
else
*oe->sd = '\0';
if (obj->description)
strcpy(oe->desc, obj->description);
else
*oe->desc = '\0';
/* end of new, possibly buggy stuff */
for(j=0; j<MAX_OBJ_AFFECT; j++)
oe->affected[j] = obj->affected[j];
st->number++;
}
int StrobeGlobalDriver::init(int sensorDev, int strobeId)
{
logI("init dev=%d id=%d", sensorDev, strobeId);
Mutex::Autolock lock(mLock);
openkd_nolock();
int err;
err = sendCommand_nolock(FLASHLIGHTIOC_X_SET_DRIVER, sensorDev, strobeId, 0);
if(err!=0)
{
logE("FLASHLIGHTIOC_X_SET_DRIVER kd_err=%d", err);
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
return 0;
}
int StrobeGlobalDriver::sendCommand_nolock(int cmd, int sensorDev, int strobeId, int arg)
{
logI("sendCommand_nolock()");
if (mStrobeHandle <= 0)
{
logE("sendCommand() mStrobeHandle <= 0 ~");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
kdStrobeDrvArg stbArg;
stbArg.sensorDev=sensorDev;
stbArg.strobeId = strobeId;
stbArg.arg=arg;
return ioctl(mStrobeHandle, cmd, &stbArg);
}
veBool consoleOption(int flag)
{
switch(flag)
{
case 't':
errno = 0;
devReg.timeOut = veArgInt(optarg);
if (errno == EINVAL) {
logE(MODULE, "wrong timeout argument");
pltExit(128);
}
break;
case 'b':
errno = 0;
devReg.baudRate = veArgInt(optarg);
if (errno == EINVAL) {
logE(MODULE, "wrong baud rate argument");
pltExit(128);
}
}
return veTrue;
}
/* Take an object from a room */
void obj_from_room(struct obj_data *object)
{
struct obj_data *i;
/* remove object from room */
if (object->in_room <= NOWHERE) {
if (object->carried_by || object->equipped_by) {
logE("Eek.. an object was just taken from a char, instead of a room");
assert(0);
}
return; /* its not in a room */
}
if (object == real_roomp(object->in_room)->contents) /* head of list */
real_roomp(object->in_room)->contents = object->next_content;
else /* locate previous element in list */
{
for (i = real_roomp(object->in_room)->contents; i &&
(i->next_content != object); i = i->next_content);
if (i) {
i->next_content = object->next_content;
} else {
logE("Couldn't find object in room");
assert(0);
}
}
if(IS_SET(real_roomp(object->in_room)->room_flags, SAVE_ROOM))
save_room(object->in_room);
object->in_room = NOWHERE;
object->next_content = 0;
}
void sortOemItemDres()
{
int maxTest=500;
int whileTestCnt=0;
int i;
int j;
//test
for(i=0;i<CAMERA_DATA_TYPE_NUM;i++)
{
if(gOemItemDres[i].id<0 || gOemItemDres[i].id>=CAMERA_DATA_TYPE_NUM)
logE("gOemItemDres[i].id is not correct!!! (<0 || > max)");
for(j=i+1;j<CAMERA_DATA_TYPE_NUM;j++)
{
if(gOemItemDres[i].id == gOemItemDres[j].id)
{
logE("gOemItemDres[i].id is not correct!!! (duplicated)");
}
}
}
OemItemDres tmp;
for(i=0;i<CAMERA_DATA_TYPE_NUM;i++)
{
while(gOemItemDres[i].id != i)
{
int pos2;
pos2 = gOemItemDres[i].id;
tmp = gOemItemDres[pos2];
gOemItemDres[pos2] = gOemItemDres[i];
gOemItemDres[i] =tmp;
whileTestCnt++;
if(whileTestCnt>maxTest)
break;
}
}
}
int StrobeGlobalDriver::openkd_nolock()
{
if(mUsers==0)
{
mStrobeHandle = open(STROBE_DEV_NAME, O_RDWR);
logI("open flash driver kd=%d", mStrobeHandle);
}
if (mStrobeHandle <= 0)
{
logE("error openkd_nolock %s: %s", STROBE_DEV_NAME, strerror(errno));
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
android_atomic_inc(&mUsers);
return 0;
}
int getCurrentClientCounts()
{
if(g_clients==NULL)
{
logE(TAG,"clients array isn't initialized!");
return 0;
}
int count=0;
TGClient * pT=NULL;
TGClient ** pHead=g_clients;
while((pT=*pHead++)!=NULL)
{
count++;
}
return count;
}
/* assign special procedures to rooms */
void assign_rooms()
{
static struct special_proc_entry specials[] = {
{ 99, Donation},
{ 500, druid_challenge_prep_room},
{ 501, druid_challenge_room},
{ 550, monk_challenge_prep_room},
{ 551, monk_challenge_room},
{ 3030, dump },
{ 13547, dump },
{ 3054, pray_for_items },
{ 2188, Magic_Fountain},
{ 2189, Magic_Fountain},
{ 13518, Fountain},
{ 11014, Fountain},
{ 5234, Fountain},
{ 3141, Fountain},
{ 13406, Fountain},
{ 22642, Fountain},
{ 22644, Fountain},
{ 22646, Fountain},
{ 22648, Fountain},
{ 13530, pet_shops },
{ 2500, entering_turbo_lift },
{ 2639, turbo_lift },
{ 2000, bank },
{ 13521, bank },
{ -1, NULL},
};
int i;
struct room_data *rp;
char buf[80];
for (i=0; specials[i].vnum>=0; i++) {
rp = real_roomp(specials[i].vnum);
if (rp==NULL) {
sprintf(buf,"assign_rooms: room %d unknown",specials[i].vnum);
logE(buf);
} else
rp->funct = specials[i].proc;
}
}
/* take an object from a char */
void obj_from_char(struct obj_data *object)
{
struct obj_data *tmp;
if (!object) {
logE("No object to be take from char.");
assert(0);
}
if (!object->carried_by) {
logE("this object is not carried by anyone");
assert(0);
}
if (!object->carried_by->carrying) {
logE("No one is carrying this object");
assert(0);
}
if (object->in_obj) {
logE("Obj in more than one place.");
assert(0);
}
if (object->equipped_by) {
logE("Obj in more than one place.");
assert(0);
}
if (object->carried_by->carrying == object) /* head of list */
object->carried_by->carrying = object->next_content;
else
{
for (tmp = object->carried_by->carrying;
tmp && (tmp->next_content != object);
tmp = tmp->next_content); /* locate previous */
if (!tmp) {
logE("Couldn't find object on character");
assert(0);
}
tmp->next_content = object->next_content;
}
IS_CARRYING_W(object->carried_by) -= GET_OBJ_WEIGHT(object);
IS_CARRYING_N(object->carried_by)--;
object->carried_by = 0;
object->equipped_by = 0; /* should be unnecessary, but, why risk it */
object->next_content = 0;
object->in_obj = 0;
}
// check library
// check some functions exist in library or not
// if it doesn't exist in library return -1
// else if it's correct return 0 and fill functions address into ppService
static int checkLib(void * dlHandler,struct TGService ** ppService)
{
static int sID=0;
struct TGService * pService=(struct TGService *) malloc(sizeof(struct TGService));
memset(pService,0,sizeof(struct TGService));
SERVICE_CREATE_FUNCTION fpC=NULL;
SERVICE_INIT_FUNCTION fpI=NULL;
SERVICE_DO_REQUEST_FUNCTION fpDo=NULL;
SERVICE_RELEASE_FUNCTION fpR=NULL;
SERVICE_DESTROY_FUNCTION fpD=NULL;
#ifdef LINUX
fpC=dlsym(dlHandler,SERVICE_CREATE_FUNCTION_NAME);
fpI=dlsym(dlHandler,SERVICE_INIT_FUNCTION_NAME);
fpDo=dlsym(dlHandler,SERVICE_DO_REQUEST_FUNCTION_NAME);
fpR=dlsym(dlHandler,SERVICE_RELEASE_FUNCTION_NAME);
fpD=dlsym(dlHandler,SERVICE_DESTROY_FUNCTION_NAME);
#elif WIN32
#endif
int flag;
if(fpC!=NULL && fpI!=NULL && fpDo!=NULL && fpR!=NULL && fpD!=NULL)
{
pService->sID=sID++;
pService->do_create=fpC;
pService->do_init=fpI;
pService->do_request=fpDo;
pService->do_release=fpR;
pService->do_destroy=fpD;
flag=0;
*ppService=pService;
logI(TAG," checked successfully flag:%d create:%s init:%s request:%s release:%s desotry:%s",flag,(long)&fpC,(long)&fpI,(long)&fpDo,(long)&fpR,(long)&fpD);
}
else
{
flag=-1;
logE(TAG," checked library error:%s %s %s %s %s",fpC,fpI,fpDo,fpR,fpD);
free(pService);
}
return flag;
}
// send signal to client
// return 0 send successfully
// return -1 send error client pipe closed
int sendSignalToClient(TGClient * pCli,char * msg)
{
if(pCli==NULL || msg==NULL || pCli->writePipe<0)
{
return -1;
}
int n=write(pCli->writePipe,msg,strlen(msg));
if(n==-1)
{
#ifdef LINUX
logE(TAG," send signal to sub process failed:%s",strerror(errno));
#elif WIN32
#endif
return -1;
}
return 0;
}
void addPowerDataSet(PowerDataSet * set, PowerData * data)
{
if (set == NULL || data == NULL) {
logE("addPowerDataSet : set or data is null");
return;
}
if (set->size == 0) {
newGroupInSet(set);
}
PowerDataGroup * group = set->dataGroups[set->size - 1];
if (isPowerGroupFull(group)) {
group = newGroupInSet(set);
}
addPowerDataGroup(group, data);
}
static void addService(struct TGService * pSer)
{
if(pSer==NULL)
{
return;
}
//FIXME linked list or array?
if(g_services==NULL)
{
logI(TAG," create new space for service array");
appendGServiceArrayCount();
g_services[0]=pSer;
return;
}
else
{
int i=0;
for(i=0;i<g_services_counts;i++)
{
struct TGService * pS=g_services[i];
if(pS==NULL)
{
g_services[i]=pSer;
logI(TAG,"load library: id:%d name:%s",pSer->sID,pSer->serviceName);
return;
}
}
//if still not return, means the array is full.
// we need append space,
if(appendGServiceArrayCount()==0)
{
g_services[i]=pSer;
logI(TAG,"load library: id:%d name:%s",pSer->sID,pSer->serviceName);
}
else
{
logE(TAG,"can not push service in to array. cause by: malloc space error");
}
}
}
double getPower(int cpu_index, PowerDataSet * set, long long timeStart, long long timeEnd)
{
long count_start, count_end;
double power_sum, power_over_s, power_over_e;
PowerData * data_start_u, *data_start_d, *data_end_u, *data_end_d;
long begin, end;
PowerData * data_begin, *data_end;
begin = 0;
end = getPowerSetNum(set) - 1;
data_begin = getPowerData(set, begin);
data_end = getPowerData(set, end);
if (timeStart < data_begin->time) {
timeStart = data_begin->time;
}
if (timeEnd > data_end->time) {
timeEnd = data_end->time;
}
count_start = findPowerDataCountByTime(timeStart, set);
count_end = findPowerDataCountByTime(timeEnd, set);
if (count_start == -1 || count_end == -1) {
logE("timeStart or timeEnd is out range");
return 0.0;
}
data_start_u = getPowerData(set, count_start);
data_start_d = getPowerData(set, count_start + 1);
data_end_u = getPowerData(set, count_end);
data_end_d = getPowerData(set, count_end + 1);
power_sum = data_end_d->core_power[cpu_index] - data_start_u->core_power[cpu_index];
power_over_s = ((timeStart - data_start_u->time) / ((double) (data_start_d->time - data_start_u->time))) * (data_start_d->core_power[cpu_index]-data_start_u->core_power[cpu_index]);
power_over_e = ((data_end_d->time - timeEnd) / ((double) (data_end_d->time - data_end_u->time))) * (data_end_d->core_power[cpu_index]-data_end_u->core_power[cpu_index]);
return power_sum - power_over_s - power_over_e;
}
static int getSensorID(CAMERA_DUAL_CAMERA_SENSOR_ENUM i4SensorDev, int& sensorId)
{
MUINT32 u4SensorID;
SensorHal*const pSensorHal = SensorHal::createInstance();
switch ( i4SensorDev )
{
case DUAL_CAMERA_MAIN_SENSOR:
pSensorHal->sendCommand(SENSOR_DEV_MAIN, SENSOR_CMD_GET_SENSOR_ID, reinterpret_cast<MINT32>(&u4SensorID), 0, 0);
break;
case DUAL_CAMERA_SUB_SENSOR:
pSensorHal->sendCommand(SENSOR_DEV_SUB, SENSOR_CMD_GET_SENSOR_ID, reinterpret_cast<MINT32>(&u4SensorID), 0, 0);
break;
case DUAL_CAMERA_MAIN_2_SENSOR:
pSensorHal->sendCommand(SENSOR_DEV_MAIN_2, SENSOR_CMD_GET_SENSOR_ID, reinterpret_cast<MINT32>(&u4SensorID), 0, 0);
break;
default: // Shouldn't happen.
logE("Invalid sensor device: %d", i4SensorDev);
break;
}
sensorId = u4SensorID;
return 0;
}
void gpsConnectedEvent(void)
{
VeVariant variant;
dbus = veDbusGetDefaultBus();
if (!dbus) {
logE(MODULE, "dbus connect failed");
pltExit(1);
}
/* Device found */
timeout = 0;
veDbusItemInit(dbus, &root);
veDbusChangeName(dbus, SERVICE_NAME);
logI(MODULE, "connected to dbus");
veItemOwnerSet(&processName, veVariantStr(&variant, pltProgramName()));
veItemOwnerSet(&processVersion, veVariantStr(&variant, pltProgramVersion()));
veItemOwnerSet(&connection, veVariantStr(&variant, interface()));
}
// read data from main process pipe
// return 0 handle successfully
// return -1 read data failed
// return 1 read data successfully but content that client sent is error
// pData is used to malloc function to allocate
int read_data_from_main_process(TGClient *pClient,int *pType, char** ppData)
{
if(pClient==NULL || pClient->readPipe<0)
{
return -1;
}
char buf[255];
memset(buf,0,sizeof(buf));
//FIXME shoule be check pipe
int n=read(pClient->readPipe,buf,sizeof(buf));
if(n==0)
{
logE(TAG,"main pipe[%d] closed",pClient->readPipe);
return -1;
}
else if(n==-1)
{
char * msg="";
GET_ERR_MSG(msg)
//FIXME error
//logE(TAG," read from pipe error:%s",msg);
return -1;
}
// copy parameters to pSer
void setServiceCreateParameters(struct TGService * pSer,const char * para)
{
if(pSer==NULL)
{
logE(TAG," service not exist");
return;
}
if(pSer->parameters==NULL)
{
pSer->parCounts=0;
int size=SERVICE_DEFAULT_PARA_COUNTS*sizeof(char *);
pSer->parameters=(char **)malloc(size);
memset(pSer->parameters,0,size);
}
// parameters is out of array need create new
else if(pSer->parCounts!=0 && (pSer->parCounts)%SERVICE_DEFAULT_PARA_COUNTS==0)
{
int size=(pSer->parCounts+SERVICE_DEFAULT_PARA_COUNTS)*sizeof(char *);
logI(TAG," create new parameters for id:%d parCounts:%d", pSer->sID,pSer->parCounts);
char ** pOld=pSer->parameters;
pSer->parameters=(char **)malloc(size);
memset(pSer->parameters,0,size);
memcpy(pSer->parameters,pOld,pSer->parCounts*sizeof(char *));
free(pOld);
}
char *pBuf=NULL;
int bufSize=strlen(para)+1;
pBuf=(char *)malloc(bufSize);
memset(pBuf,0,bufSize);
strncpy(pBuf,para,bufSize-1);
pBuf[bufSize-1]='\0';
pSer->parameters[pSer->parCounts++]=pBuf;
logD(TAG," parameters:%d, %s",pSer->parCounts,pSer->parameters);
}