/* virtual */ SysStatusUval
FileLinuxFile::readv(struct iovec* vec, uval vecCount,
ThreadWait **tw, GenState &moreAvail)
{
FLFDEBUG("readv");
SysStatusUval rc;
uval length_read;
char* buf_read;
uval length = vecLength(vec,vecCount);
lock();
moreAvail.state = FileLinux::READ_AVAIL|FileLinux::WRITE_AVAIL;
rc = locked_readAlloc(length, buf_read, tw);
if (_FAILURE(rc)) {
unLock();
//semantics shift from EOF error to 0 length on EOF
if (_SCLSCD(rc) == FileLinux::EndOfFile) {
moreAvail.state = FileLinux::ENDOFFILE;
return 0;
}
return rc;
}
length_read = _SGETUVAL(rc);
if (length_read) {
memcpy_toiovec(vec, buf_read, vecCount, length_read);
locked_readFree(buf_read);
}
unLock();
return rc;
}
/* virtual */ SysStatusUval
FileLinuxFile::writev(const struct iovec *vec, uval vecCount,
ThreadWait **tw, GenState &moreAvail)
{
FLFDEBUG("writev");
SysStatusUval rc;
uval length_write;
char* buf_write;
uval length = vecLength(vec, vecCount);
lock();
moreAvail.state = FileLinux::READ_AVAIL|FileLinux::WRITE_AVAIL;
rc = locked_writeAlloc(length, buf_write, tw);
if (_FAILURE(rc)) {
unLock();
return rc;
}
length_write = _SGETUVAL(rc);
if (length_write) {
memcpy_fromiovec(buf_write, vec, vecCount, length_write);
locked_writeFree(buf_write);
}
unLock();
return rc;
}
void JobAf::deleteNode( RenderContainer * renders, MonitorContainer * monitoring)
{
if( m_id == AFJOB::SYSJOB_ID )
{
AFCommon::QueueLogError("System job can't be zombie");
return;
}
if( m_deletion == false )
{
m_state = AFJOB::STATE_OFFLINE_MASK;
lock();
m_deletion = true;
if( m_custom_data.size() || m_user->getCustomData().size())
{
std::vector<std::string> events;
events.push_back("JOB_DELETED");
emitEvents(events);
}
if( getRunningTasksNumber() && (renders != NULL) && (monitoring != NULL))
{
restartAllTasks("Job deletion.", renders, monitoring, AFJOB::STATE_RUNNING_MASK);
if( monitoring ) monitoring->addJobEvent( af::Monitor::EVT_jobs_change, getId(), getUid());
return;
}
}
if( getRunningTasksNumber() )
{
AF_ERR << "runningtaskscounter = " << getRunningTasksNumber();
return;
}
if( false == m_command_post.empty())
{
SysJob::AddPostCommand( m_command_post, m_blocks_num > 0 ? m_blocks_data[0]->getWDir(): "", m_user_name, m_name);
appendLog( std::string("Executing job post command:\n") + m_command_post);
}
for( int b = 0; b < m_blocks_num; b++)
{
if( m_blocks_data[b]->hasCmdPost())
{
SysJob::AddPostCommand( m_blocks_data[b]->getCmdPost(), m_blocks_data[b]->getWDir(), m_user_name, m_name);
appendLog( std::string("Executing block[") + m_blocks_data[b]->getName() + "] post command:\n" + m_blocks_data[b]->getCmdPost());
}
}
setZombie();
AFCommon::DBAddJob( this);
if( monitoring ) monitoring->addJobEvent( af::Monitor::EVT_jobs_del, getId(), getUid());
AFCommon::QueueLog("Deleting a job: " + v_generateInfoString());
unLock();
}
void SocketUser::Close()
{
unLock();
if( mSocket ) {
mSocket->CloseChennel();
delete mSocket;
HubUser::Close();
}
mSocket = NULL;
}
void MSLogEx(MS_LOG_LEVEL level,const char *logStr, ...)
{
lock(&(g_MSLog.lock));
char msg[2048] = "\0";
va_list varArg;
//firstly check the current line's level with g_MSLog.level
if (level > g_MSLog.level)
{
unLock(&(g_MSLog.lock));
return;
}
memset(msg,0,sizeof(msg));
va_start(varArg, logStr);
MSVsnprintf(msg, sizeof(msg), logStr, varArg);
va_end(varArg);
g_MSLog.logCB(g_MSLog.type,msg,strlen(msg));
unLock(&(g_MSLog.lock));
}
/* virtual */ SysStatusUval
FileLinuxPacket::destroy()
{
lock();
if (remote) {
freeGlobal(remote,remoteLen);
remote = NULL;
remoteLen = 0;
}
if (local) {
freeGlobal(local,localLen);
local = NULL;
localLen = 0;
}
unLock();
return FileLinuxStream::destroy(); // no special state
}
/* virtual */ SysStatusUval
FileLinuxFile::pread(const char *buf, uval nbytes, uval offset)
{
FLFDEBUG("readv");
SysStatusUval rc, rcret;
char* buf_read;
lock();
// retrieve and save current position
if (buffer == NULL) locked_initBuffer(uval(~0));
rc = buffer->setFilePosition(0, FileLinux::RELATIVE);
_IF_FAILURE_RET(rc);
uval savedOffset = _SGETUVAL(rc);
rc = buffer->setFilePosition(offset, FileLinux::ABSOLUTE);
// tassertMsg only because it didn't fail on the first call, it should
// work now
tassertMsg(_SUCCESS(rc), "rc 0x%lx\n", rc);
rcret = locked_readAlloc(nbytes, buf_read, NULL);
// restore previous file offset
rc = buffer->setFilePosition(savedOffset, FileLinux::ABSOLUTE);
// tassertMsg only because it didn't fail on the first 2 calls, it should
// work now
tassertMsg(_SUCCESS(rc), "rc 0x%lx\n", rc);
// return value from locked_readAlloc
if (_FAILURE(rcret)) {
//semantics shift from EOF error to 0 length on EOF
if (_SCLSCD(rc) == FileLinux::EndOfFile) {
rcret = _SRETUVAL(0);
}
} else {
tassertMsg(_SGETUVAL(rcret) > 0, "?");
memcpy((void*)buf, buf_read, _SGETUVAL(rcret));
locked_readFree(buf_read);
}
unLock();
return rcret;
}
/* virtual */ SysStatusUval
FileLinuxFile::pwrite(const char *buf, uval nbytes, uval offset)
{
FLFDEBUG("readv");
SysStatusUval rc, rcret;
char* buf_write;
lock();
// retrieve and save current position
if (buffer == NULL) locked_initBuffer(uval(~0));
rc = buffer->setFilePosition(0, FileLinux::RELATIVE);
_IF_FAILURE_RET(rc);
uval savedOffset = _SGETUVAL(rc);
rc = buffer->setFilePosition(offset, FileLinux::ABSOLUTE);
// tassertMsg only because it didn't fail on the first call, it should
// work now
tassertMsg(_SUCCESS(rc), "rc 0x%lx\n", rc);
rcret = locked_writeAlloc(nbytes, buf_write, NULL);
// restore previous file offset
rc = buffer->setFilePosition(savedOffset, FileLinux::ABSOLUTE);
// tassertMsg only because it didn't fail on the first 2 calls, it should
// work now
tassertMsg(_SUCCESS(rc), "rc 0x%lx\n", rc);
if (_SUCCESS(rcret)) {
uval length_write = _SGETUVAL(rcret);
if (length_write) {
memcpy(buf_write, (void*)buf, length_write);
locked_writeFree(buf_write);
}
}
unLock();
return rcret;
}
void *thread_main(void *arg)
{
int n, buflen;
char tmp;
char buffer[BUFSIZE];
wiringPiSetup();
/* INIT */
pinMode(PIN, OUTPUT);
digitalWrite(PIN,LOW);
softPwmCreate(PIN, 0, 200);
/* UN-LOCK */
unLock();
printf("LOCKER ID : %s\n", sl_iot_id);
printf("Smart Locker IoT : Start.\n");
do
{
n = read(sock, &tmp, 1);
if (n < 0)
error("ERROR reading from socket");
if (tmp != '\x2')
continue;
buflen = 0;
do
{
n = read(sock, &tmp, 1);
if (n < 0)
error("ERROR reading from socket");
if (tmp == '\x3')
break;
// TODO: if the buffer's capacity has been reached, either reallocate the buffer with a larger size, or fail the operation...
buffer[buflen] = tmp;
++buflen;
}
while (1);
char data_buffer[10][30];
char* token = NULL;
char tok[] = "{},:\"";
token = strtok(buffer, tok);
int i = 0;
while (token != NULL)
{
strcpy(data_buffer[i], token);
token = strtok(NULL, tok);
i++;
}
if(!strcmp(sl_iot_id, data_buffer[5]))
{
lock();
printf("SMART LOCKER - STATE : LOCK\n");
data_buffer[5][0] = '\0';
}
//printf("%*.*s\n", buflen, buflen, buffer);
//break;
}
while (1);
pthread_exit((void *) 0);
}
~Mutex(void)
{
unLock();
pthread_mutex_destroy(&_mutex);
};
int main(int argc, char* argv[])
{
int shmid ;
char line[128];
int fd_s, fd_r ;
//open fifo 12.fifp 21.fifo
fd_s = open("./12.fifo", O_WRONLY);
fd_r = open("./21.fifo", O_RDONLY);
printf("fd_s: %d, fd_r: %d\n", fd_s, fd_r);
//shm
shmid = shmget((key_t)1234, sizeof(mem_t), IPC_CREAT|0666);
if(shmid == -1)
{
perror("shmget");
exit(1);
}
pmem_t pm = (pmem_t)shmat(shmid, NULL, 0);
if((void*)pm == (void*)-1)
{
perror("shmat");
exit(1);
}
pm ->m_lock = 1 ;
pm ->m_unshow = 0 ;
//select
fd_set rds ;
struct timeval tm ;
int ret ;
while(1)
{
FD_ZERO(&rds);
FD_SET(0, &rds);
FD_SET(fd_r, &rds);
tm.tv_usec = 0 ;
tm.tv_sec = 5;
ret = select(1024, &rds, NULL, NULL, &tm);
if(ret == 0)
{
continue ;
}else if(ret > 0)
{
if(FD_ISSET(0, &rds))
{
memset(line, 0, 128);
read(0, line, 127);
write(fd_s, line, strlen(line));
}
if(FD_ISSET(fd_r, &rds ))
{
memset(line, 0, 128);
read(fd_r, line, 127);
Lock(pm);
while( pm -> m_unshow == 1)
{
unLock(pm);
sleep(1);
Lock(pm);
}
strcpy(pm ->m_buf, line);
pm ->m_unshow = 1 ;
unLock(pm);
}
}
}
close(fd_s);
close(fd_r);
shmdt(pm);
shmctl(shmid, IPC_RMID, NULL);
return 0 ;
}
void Login::compare(const QByteArray &input, const QByteArray &passcode) {
if (_generator.hash(input, QCryptographicHash::Sha3_512) == passcode) emit unLock();
}
