/*! \fn float Sonar::DisplayMeasurement() * \brief Calculate the distance measurement from the time of flight. * \return The distance calculated. */ float Sonar::DisplayMeasurement() { if (TimeDiff().tv_sec == 0) { float time = TimeDiff().tv_nsec/1000000000.f; float dist = 340.29*(time/2); if (dist < 3.f && dist > 0) { if (dist < _minDist) { _minDist = dist; } if (dist > _maxDist) { _maxDist = dist; } #if 0 // no longer want to print out the message. printf("Time taken is: %fs\n", time); printf("Dist is: %fm\t minDist: %fm\t maxDist: %fm\n", dist, _minDist, _maxDist); fflush(stdout); #endif return dist; } } return 0.f; }
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow) { HWND hwnd; MSG msg; WNDCLASSEX wndclass; wndclass.cbSize = sizeof(wndclass); wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; wndclass.lpfnWndProc = WndProc; wndclass.cbClsExtra = 0; wndclass.cbWndExtra = 0; wndclass.hInstance = hInstance; wndclass.hIcon = LoadIcon (hInstance, "PROGICON"); wndclass.hCursor = LoadCursor (NULL, IDC_ARROW); wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH); wndclass.lpszMenuName = NULL; wndclass.lpszClassName = APPNAME; wndclass.hIconSm = LoadIcon (hInstance, "PROGICON"); RegisterClassEx (&wndclass); hwnd = CreateWindow(APPNAME, APPNAME, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 300, NULL, NULL, hInstance, NULL); ShowWindow (hwnd, iCmdShow); UpdateWindow (hwnd); TimeDiff(); // init TimeDiff function // init AV environment g_Env.Init(); // ** MAIN LOOP ** while (1) { if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) { if (!GetMessage (&msg, NULL, 0, 0)) return msg.wParam; TranslateMessage (&msg); DispatchMessage (&msg); } // change AV state float td = (float) TimeDiff(); if (td != 0) { g_Env.SetFPS(1/td); } g_Env.DrawBuffer(td); g_Env.PlaceCamera(); SwapBuffers(g_hDC); } return msg.wParam; }
float CEnvironment::TimeWeight(float val, float min_t, float max_t) { float weight = 0.f; float length = TimeDiff(min_t,max_t); if (!fis_zero(length,EPS)){ if (min_t>max_t){ if ((val>=min_t)||(val<=max_t)) weight = TimeDiff(min_t,val)/length; }else{ if ((val>=min_t)&&(val<=max_t)) weight = TimeDiff(min_t,val)/length; } clamp (weight,0.f,1.f); } return weight; }
int handle() { const int maxFPS = tLXOptions ? tLXOptions->nMaxFPS : 100; TimeDiff max_frame_time = TimeDiff(MAX(0.01f, (maxFPS > 0) ? 1.0f/(float)maxFPS : 0.0f)); AbsTime lastTime = GetTime(); while(!sharedData->quitSignal) { NLsocket s; NLint ret = nlPollGroup(sharedData->nlGroup, pollType, &s, /* amount of sockets */ 1, /* timeout */ (NLint)max_frame_time.milliseconds()); // if no error, ret is amount of sockets which triggered the event if(ret > 0) { switch(pollType) { case NL_READ_STATUS: if(!pushNewDataEvent()) return -1; break; case NL_ERROR_STATUS: if(!pushErrorEvent()) return -1; break; } } AbsTime curTime = GetTime(); if(curTime - lastTime < max_frame_time) { SDL_Delay( (Uint32)( ( max_frame_time - (curTime - lastTime) ).milliseconds() ) ); } lastTime = curTime; } return 0; }
void CEnvironment::SetGameTime(float game_time, float time_factor) { if (bWFX) wfx_time -= TimeDiff(fGameTime,game_time); fGameTime = game_time; fTimeFactor = time_factor; }
void display(void) { float td = TimeDiff(); g_Env.DrawBuffer(td); if (td != 0) { g_Env.SetFPS(1/td); } g_Env.PlaceCamera(); glutSwapBuffers(); }
void CGBLStorageManagerTestBBBase::StopAndShowTimeMeasure(ofstream &_trace, float &totalTime) { float executionTime = TimeDiff(); totalTime += executionTime; XString disp = ""; disp << executionTime; _trace << "Execution time: " << disp.Str() << " seconds" <<endl; }
END_TEST START_TEST(TIMEDIFF4) { std::ostringstream oss; oss << TimeDiff (0.005, false); ck_assert_str_eq (oss.str ().c_str (), "5ms"); }
bool CEnvironment::SetWeatherFX(shared_str name) { if (bWFX) return false; if (name.size()){ EnvsMapIt it = WeatherFXs.find(name); R_ASSERT3 (it!=WeatherFXs.end(),"Invalid weather effect name.",*name); EnvVec* PrevWeather = CurrentWeather; VERIFY(PrevWeather); CurrentWeather = &it->second; CurrentWeatherName = it->first; float rewind_tm = WFX_TRANS_TIME*fTimeFactor; float start_tm = fGameTime+rewind_tm; float current_length; float current_weight; if (Current[0]->exec_time>Current[1]->exec_time){ float x = fGameTime>Current[0]->exec_time?fGameTime-Current[0]->exec_time:(DAY_LENGTH-Current[0]->exec_time)+fGameTime; current_length = (DAY_LENGTH-Current[0]->exec_time)+Current[1]->exec_time; current_weight = x/current_length; }else{ current_length = Current[1]->exec_time-Current[0]->exec_time; current_weight = (fGameTime-Current[0]->exec_time)/current_length; } clamp (current_weight,0.f,1.f); std::sort (CurrentWeather->begin(),CurrentWeather->end(),sort_env_etl_pred); CEnvDescriptor* C0 = CurrentWeather->at(0); CEnvDescriptor* C1 = CurrentWeather->at(1); CEnvDescriptor* CE = CurrentWeather->at(CurrentWeather->size()-2); CEnvDescriptor* CT = CurrentWeather->at(CurrentWeather->size()-1); C0->copy (*Current[0]); C0->exec_time = NormalizeTime(fGameTime-((rewind_tm/(Current[1]->exec_time-fGameTime))*current_length-rewind_tm)); C1->copy (*Current[1]); C1->exec_time = NormalizeTime(start_tm); for (EnvIt t_it=CurrentWeather->begin()+2; t_it!=CurrentWeather->end()-1; t_it++) (*t_it)->exec_time= NormalizeTime(start_tm+(*t_it)->exec_time_loaded); SelectEnv (PrevWeather,WFX_end_desc[0],CE->exec_time); SelectEnv (PrevWeather,WFX_end_desc[1],WFX_end_desc[0]->exec_time+0.5f); CT->copy (*WFX_end_desc[0]);CT->exec_time = NormalizeTime(CE->exec_time+rewind_tm); wfx_time = TimeDiff(fGameTime,CT->exec_time); bWFX = true; // sort wfx envs std::sort (CurrentWeather->begin(),CurrentWeather->end(),sort_env_pred); Current[0] = C0; Current[1] = C1; #ifdef WEATHER_LOGGING Msg ("Starting WFX: '%s' - %3.2f sec",*name,wfx_time); for (EnvIt l_it=CurrentWeather->begin(); l_it!=CurrentWeather->end(); l_it++) Msg (". Env: '%s' Tm: %3.2f",*(*l_it)->sect_name,(*l_it)->exec_time); #endif }else{ #ifndef _EDITOR FATAL ("! Empty weather effect name"); #endif } return true; }
void CGBLStorageManagerTestBBBase::StopAndOutputTimeMeasure( CKContext *ctx ) { float executionTime = TimeDiff(); totalExecutionTime += executionTime; XString disp; disp << "Execution time: " << executionTime << " seconds"; OutputTestText( ctx, disp ); }
bool DynamicTimeout::Expired() { auto timedout = TimeDiff(begin, millis()) > timeout; if (timedout) { timeout += timeoutBase; if (timeout > timeoutMax) timeout = timeoutBase; begin = millis(); } return timedout; }
//----------------------------------------------------------------------------- // Filter test void TestFilter() { double phase = 0.0; double maxPhase = 2.0 * M_PI; double frequency = 30; double rate = frequency * 5; double phaseStep; double time = 0.0; double timeStep; int value; //int max = 100; // Amplitude int i; int total; int filtered; Signal signal(rate); Filter filter(rate, 30); int ret; timespec start; timespec end; double length = 1.0; int diff; double sec; signal.Init(); filter.Init(); phaseStep = maxPhase * frequency / rate; timeStep = 1 / rate; total = rate * length; clock_gettime(CLOCK_REALTIME, &start); for(i = 0; i < total; i++) { time += timeStep; value = RandomInt(1, 9);//5 + sin(phase) * max; ret = filter.Get(value, filtered); if(!ret) signal.Add(filtered); else signal.Add(-777); phase += phaseStep; if(phase >= maxPhase) phase -= maxPhase; printf("%5.2f %4d, avg=%4d\n", time, value, filter._average); } clock_gettime(CLOCK_REALTIME, &end); diff = TimeDiff(start, end); sec = (double)diff / 1e6; printf("Load=%0.6f, time=%0.3f sec\n", sec / length, sec); //signal.Show(); }
inline void Sleep(unsigned long usec) { if (usec == 0) goto done; struct timeval sleepstart; gettimeofday(&sleepstart,NULL); while(TimeDiff(&sleepstart,NULL) <= usec) { //CheckHallState(); usleep(SLEEP_GRAIN); } done: (void)0; //CheckHallState(); }
void CapFPS() { const TimeDiff fMaxFrameTime = TimeDiff( (tLXOptions->nMaxFPS > 0) ? (1.0f / (float)tLXOptions->nMaxFPS) : 0.0f ); const AbsTime currentTime = GetTime(); // tLX->currentTime is old time // Cap the FPS if(currentTime - tLX->currentTime < fMaxFrameTime) SDL_Delay((Uint32)(fMaxFrameTime - (currentTime - tLX->currentTime)).milliseconds()); else // do at least one small break, else it's possible that we never receive signals from our OS SDL_Delay(1); }
void CEnvironment::SetGameTime(float game_time, float time_factor) { #ifndef _EDITOR if (m_paused) { g_pGameLevel->SetEnvironmentGameTimeFactor (iFloor(fGameTime*1000.f), fTimeFactor); return; } #endif if (bWFX) wfx_time -= TimeDiff(fGameTime,game_time); fGameTime = game_time; fTimeFactor = time_factor; }
__declspec(dllexport) int HEIWriteIOEx ( HEIDevice *apDevice[], BYTE *apData[], WORD aSizeofData[], BYTE *apReturnData[], WORD aSizeofReturnData[], int aErrorCode[], int DeviceCount, DWORD Timeout ) { DWORD StartTime = HEIIGetCounter(); int idx = 0; BOOL Done = FALSE; BOOL OldPP = FALSE; for(idx = 0; idx < DeviceCount; idx++) { /* Handle NULL device */ if(!apDevice[idx]) continue; /* Force parallel packet mode */ OldPP = apDevice[idx]->ParallelPackets; apDevice[idx]->ParallelPackets = TRUE; /* Init error code */ aErrorCode[idx] = HEIE_NO_RESPONSE; /* Send request */ HEIWriteIO(apDevice[idx], apData[idx], aSizeofData[idx], apReturnData[idx], &aSizeofReturnData[idx]); /* Check for response */ GetResponseEx(apDevice, apReturnData, aSizeofReturnData, aErrorCode, idx+1); /* Restore parallel packet mode */ apDevice[idx]->ParallelPackets = OldPP; } /* Spin on GetResponseEx waiting for timeout */ while(!Done) { Done = GetResponseEx(apDevice, apReturnData, aSizeofReturnData, aErrorCode, idx); if(TimeDiff(StartTime, HEIIGetCounter()) >= Timeout) return HEIE_TIMEOUT; } return 0; }
void display(void) { static int numCalls = 10; static float lastTD = 0.02; if (numCalls++ >= 10) // calculate new TimeDiff value every ten frames (smoother on MacOS) { float td = TimeDiff() / 10; lastTD = td; numCalls = 0; } g_Env.DrawBuffer(lastTD); if (lastTD != 0) { g_Env.SetFPS(1/lastTD); } g_Env.PlaceCamera(); glutSwapBuffers(); }
//----------------------------------------------------------------------------- // Data received // socket - the socket void TestThread::OnSocketRead(Socket* socket) { int read; // Number of bytes read int ret; timespec curr; int diff; // Read socket data until there is nothing more to read do { ret = socket->Receive(_data, DATA_SIZE - 1, read); if(ret) { printf("Can't read from the socket\n"); return; } if(!read) // Sometimes we can get a read signal with nothing to read break; _data[read] = 0; if(_mode == 's') { // Server if(_connection == 's') { // Don't send back in multicast mode ret = socket->Send(_data, read); // Send the data back to the client if(ret) printf("Can't send back: %s\n", socket->_errorDescr); } } else { // Client clock_gettime(CLOCK_REALTIME, &curr); // Get current time diff = TimeDiff(_sendTime, curr) / 2; // Save the one-way time, not round-trip _times->Add(diff); // Send more _count--; if(!_count) { printf("One-way times (microseconds):\n"); _times->Get(); exit(0); } else { clock_gettime(CLOCK_REALTIME, &_sendTime); // Get current time _client->Send("Test", 5); } } } while(read > 0); }
//----------------------------------------------------------------------------- // Data received from a queue // data - queue data void QueueThread::OnQueueData(Queue::Data* data) { timespec curr; int diff; if(_send) { // Sending thread clock_gettime(CLOCK_REALTIME, &curr); // Get current time diff = TimeDiff(_sendTime, curr) / 2; // Save the one-way time, not round-trip _times->Add(diff); free(data->_data); // This is the buffer we allocated here in OnTimer // Send more _count--; if(!_count) { printf("One-way times (microseconds):\n"); _times->Get(); exit(0); } else Send(); } else { // Replying queue _queue->Send(Queue::TYPE_MEMORY, data->_data, data->_size); //printf("Received %d bytes: %s\n", data->_size, (char*)data->_data); } }
static int reply_lanman1(char *inbuf, char *outbuf) { int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0); int secword=0; time_t t = time(NULL); global_encrypted_passwords_negotiated = lp_encrypted_passwords(); if (lp_security()>=SEC_USER) secword |= NEGOTIATE_SECURITY_USER_LEVEL; if (global_encrypted_passwords_negotiated) secword |= NEGOTIATE_SECURITY_CHALLENGE_RESPONSE; set_message(outbuf,13,global_encrypted_passwords_negotiated?8:0,True); SSVAL(outbuf,smb_vwv1,secword); /* Create a token value and add it to the outgoing packet. */ if (global_encrypted_passwords_negotiated) { get_challenge(smb_buf(outbuf)); SSVAL(outbuf,smb_vwv11, 8); } Protocol = PROTOCOL_LANMAN1; /* Reply, SMBlockread, SMBwritelock supported. */ SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD); SSVAL(outbuf,smb_vwv2,max_recv); SSVAL(outbuf,smb_vwv3,lp_maxmux()); /* maxmux */ SSVAL(outbuf,smb_vwv4,1); SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support readbraw writebraw (possibly) */ SIVAL(outbuf,smb_vwv6,sys_getpid()); SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60); put_dos_date(outbuf,smb_vwv8,t); return (smb_len(outbuf)+4); }
Timestamp Timestamp::fromUtcTime(UtcTimeVal val) { val -= (TimeDiff(0x01b21dd2) << 32) + 0x13814000; val /= 10; return Timestamp(val); }
void *rtos_msg_wait(uint16_t id, uint16_t timeout) { // check if there was a timeout configured if (timeout != 0) { // elements to parse the timed thread list struct thread_c *next; struct thread_c *prev; // get the current time uint32_t now = TimeGet(); // compute the delay in number of RTC cycles int32_t delay = timeout * 32; // compute the expiration date uint32_t expiration = now + delay; // compute the new expiration date rtos_env.threads[rtos_env.thread_cur].timeout.date = expiration; // add the timeout in the list of timed threads prev = rtos_env.timed; if ((prev == NULL) || (TimeDiff(prev->timeout.date, now) > delay)) { rtos_env.timed = &(rtos_env.threads[rtos_env.thread_cur]); rtos_env.timed->timeout.next = prev; } else { do { // find the next thread in the list next = prev->timeout.next; // if the next one is NULL, then exit (end of the list) if (next == NULL) break; // check if the next one should expire after the new one if (delay < TimeDiff(next->timeout.date, now)) break; // move to the next one in the list prev = next; } while (1); // insert the new item between the prev and the next rtos_env.threads[rtos_env.thread_cur].timeout.next = next; prev->timeout.next = &(rtos_env.threads[rtos_env.thread_cur]); } } // wait for the expected message do { void *msg; uint8_t msg_src; uint16_t msg_id; // wait for the next message msg = rtos_msg_get(&msg_src, &msg_id); // check if this is the expected message if (msg_id == id) { return msg; } // otherwise, save the message rtos_msg_store(msg); } while (1); }
TimeStamp::UtcTimeVal TimeStamp::UtcTime() const { return m_ts*10 + (TimeDiff(0x01b21dd2) << 32) + 0x13814000; }
Timespan& Timespan::assign(long seconds, long microSeconds) { _span = TimeDiff(seconds)*SECONDS + TimeDiff(microSeconds); return *this; }
BOOL cli_negprot(struct cli_state *cli) { char *p; int numprots; int plength; memset(cli->outbuf,'\0',smb_size); /* setup the protocol strings */ for (plength=0,numprots=0; prots[numprots].name && prots[numprots].prot<=cli->protocol; numprots++) plength += strlen(prots[numprots].name)+2; set_message(cli->outbuf,0,plength,True); p = smb_buf(cli->outbuf); for (numprots=0; prots[numprots].name && prots[numprots].prot<=cli->protocol; numprots++) { *p++ = 2; p += clistr_push(cli, p, prots[numprots].name, -1, STR_CONVERT|STR_TERMINATE); } SCVAL(cli->outbuf,smb_com,SMBnegprot); cli_setup_packet(cli); SCVAL(smb_buf(cli->outbuf),0,2); cli_send_smb(cli); if (!cli_receive_smb(cli)) return False; show_msg(cli->inbuf); if (cli_is_error(cli) || ((int)SVAL(cli->inbuf,smb_vwv0) >= numprots)) { return(False); } cli->protocol = prots[SVAL(cli->inbuf,smb_vwv0)].prot; if (cli->protocol >= PROTOCOL_NT1) { /* NT protocol */ cli->sec_mode = CVAL(cli->inbuf,smb_vwv1); cli->max_mux = SVAL(cli->inbuf, smb_vwv1+1); cli->max_xmit = IVAL(cli->inbuf,smb_vwv3+1); cli->sesskey = IVAL(cli->inbuf,smb_vwv7+1); cli->serverzone = SVALS(cli->inbuf,smb_vwv15+1); cli->serverzone *= 60; /* this time arrives in real GMT */ cli->servertime = interpret_long_date(cli->inbuf+smb_vwv11+1); memcpy(cli->cryptkey,smb_buf(cli->inbuf),8); cli->capabilities = IVAL(cli->inbuf,smb_vwv9+1); if (cli->capabilities & CAP_RAW_MODE) { cli->readbraw_supported = True; cli->writebraw_supported = True; } /* work out if they sent us a workgroup */ if (smb_buflen(cli->inbuf) > 8) { clistr_pull(cli, cli->server_domain, smb_buf(cli->inbuf)+8, sizeof(cli->server_domain), smb_buflen(cli->inbuf)-8, STR_UNICODE|STR_NOALIGN); } } else if (cli->protocol >= PROTOCOL_LANMAN1) { cli->sec_mode = SVAL(cli->inbuf,smb_vwv1); cli->max_xmit = SVAL(cli->inbuf,smb_vwv2); cli->sesskey = IVAL(cli->inbuf,smb_vwv6); cli->serverzone = SVALS(cli->inbuf,smb_vwv10); cli->serverzone *= 60; /* this time is converted to GMT by make_unix_date */ cli->servertime = make_unix_date(cli->inbuf+smb_vwv8); cli->readbraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x1) != 0); cli->writebraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x2) != 0); memcpy(cli->cryptkey,smb_buf(cli->inbuf),8); } else { /* the old core protocol */ cli->sec_mode = 0; cli->serverzone = TimeDiff(time(NULL)); } cli->max_xmit = MIN(cli->max_xmit, CLI_BUFFER_SIZE); /* a way to force ascii SMB */ if (getenv("CLI_FORCE_ASCII")) { cli->capabilities &= ~CAP_UNICODE; } return True; }
Timespan& Timespan::assign(int days, int hours, int minutes, int seconds, int microSeconds) { _span = TimeDiff(microSeconds) + TimeDiff(seconds)*SECONDS + TimeDiff(minutes)*MINUTES + TimeDiff(hours)*HOURS + TimeDiff(days)*DAYS; return *this; }
Timespan::Timespan(int days, int hours, int minutes, int seconds, int microSeconds): _span(TimeDiff(microSeconds) + TimeDiff(seconds)*SECONDS + TimeDiff(minutes)*MINUTES + TimeDiff(hours)*HOURS + TimeDiff(days)*DAYS) { }
Timespan::Timespan(long seconds, long microSeconds): _span(TimeDiff(seconds)*SECONDS + microSeconds) { }
/**************************************************************************** send a negprot command ****************************************************************************/ BOOL cli_negprot(struct cli_state *cli) { Q_NEGPROT qw; R_NEGPROT rw; Q_NEGPROT_D qd; R_NEGPROT_D rd; Q_NEGPROT_D_0 *q0 = &qd.ctr.d0; ZERO_STRUCT(qw); ZERO_STRUCT(rw); ZERO_STRUCT(qd); ZERO_STRUCT(rd); qd.wcount = 0; q0->protocol = prot_buf; qw.wcount = 0; cli->nterr = cli_SMBnegprot(cli->hnd, &qw, &rw, &qd, &rd, NULL, NULL); if (cli->nterr != 0) return False; if (rw.wcount == 17) { R_NEGPROT_17 *np = &rw.ctr.r17; R_NEGPROT_D_13 *nd = &rd.ctr.d17; smb_set_protocol(cli->hnd, prots[np->DialectIndex].prot); if (prots[np->DialectIndex].prot >= PROTOCOL_NT1) { /* NT protocol */ cli->sec_mode = np->SecurityMode; cli->max_mux = np->MaxMpxCount; cli->max_xmit = np->MaxBufferSize; cli->sesskey = np->SessionKey; cli->serverzone = np->ServerTimeZone; cli->serverzone *= 60; /* this time arrives in real GMT */ cli->servertime = interpret_long_date(&np->SystemTime); memcpy(cli->cryptkey, nd->SecurityBlob, 8); cli->capabilities = np->Capabilities; if (cli->capabilities & 1) { cli->readbraw_supported = True; cli->writebraw_supported = True; } } } else if (rw.wcount == 13) { R_NEGPROT_13 *np = &rw.ctr.r13; R_NEGPROT_D_13 *nd = &rd.ctr.d13; smb_set_protocol(cli->hnd, prots[np->DialectIndex].prot); if (prots[np->DialectIndex].prot >= PROTOCOL_LANMAN1) { cli->sec_mode = np->SecurityMode; cli->max_xmit = np->MaxBufferSize; cli->sesskey = np->SessionKey; cli->serverzone = np->ServerTimeZone; cli->serverzone *= 60; /* this time is converted to GMT by make_unix_date */ cli->servertime = make_unix_date(&np->ServerTimeDate); cli->readbraw_supported = (np->RawMode & 0x1) != 0; cli->writebraw_supported = (np->RawMode & 0x2) != 0; memcpy(cli->cryptkey, nd->SecurityBlob, 8); } } else { /* the old core protocol */ cli->sec_mode = 0; cli->serverzone = TimeDiff(time(NULL)); } cli->max_xmit = MIN(cli->max_xmit, CLI_BUFFER_SIZE); return True; }
static int reply_nt1(char *inbuf, char *outbuf) { /* dual names + lock_and_read + nt SMBs + remote API calls */ int capabilities = CAP_NT_FIND|CAP_LOCK_AND_READ| CAP_LEVEL_II_OPLOCKS; int secword=0; time_t t = time(NULL); char *p, *q; BOOL negotiate_spnego = False; global_encrypted_passwords_negotiated = lp_encrypted_passwords(); /* do spnego in user level security if the client supports it and we can do encrypted passwords */ if (global_encrypted_passwords_negotiated && (lp_security() != SEC_SHARE) && lp_use_spnego() && (SVAL(inbuf, smb_flg2) & FLAGS2_EXTENDED_SECURITY)) { negotiate_spnego = True; capabilities |= CAP_EXTENDED_SECURITY; add_to_common_flags2(FLAGS2_EXTENDED_SECURITY); /* Ensure FLAGS2_EXTENDED_SECURITY gets set in this reply (already partially constructed. */ SSVAL(outbuf,smb_flg2, SVAL(outbuf,smb_flg2) | FLAGS2_EXTENDED_SECURITY); } capabilities |= CAP_NT_SMBS|CAP_RPC_REMOTE_APIS|CAP_UNICODE; if (lp_unix_extensions()) { capabilities |= CAP_UNIX; } if (lp_large_readwrite() && (SMB_OFF_T_BITS == 64)) capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX|CAP_W2K_SMBS; if (SMB_OFF_T_BITS == 64) capabilities |= CAP_LARGE_FILES; if (lp_readraw() && lp_writeraw()) capabilities |= CAP_RAW_MODE; if (lp_nt_status_support()) capabilities |= CAP_STATUS32; if (lp_host_msdfs()) capabilities |= CAP_DFS; if (lp_security() >= SEC_USER) secword |= NEGOTIATE_SECURITY_USER_LEVEL; if (global_encrypted_passwords_negotiated) secword |= NEGOTIATE_SECURITY_CHALLENGE_RESPONSE; if (lp_server_signing()) { if (lp_security() >= SEC_USER) { secword |= NEGOTIATE_SECURITY_SIGNATURES_ENABLED; /* No raw mode with smb signing. */ capabilities &= ~CAP_RAW_MODE; if (lp_server_signing() == Required) secword |=NEGOTIATE_SECURITY_SIGNATURES_REQUIRED; srv_set_signing_negotiated(); } else { DEBUG(0,("reply_nt1: smb signing is incompatible with share level security !\n")); if (lp_server_signing() == Required) { exit_server("reply_nt1: smb signing required and share level security selected."); } } } set_message(outbuf,17,0,True); SCVAL(outbuf,smb_vwv1,secword); Protocol = PROTOCOL_NT1; SSVAL(outbuf,smb_vwv1+1,lp_maxmux()); /* maxmpx */ SSVAL(outbuf,smb_vwv2+1,1); /* num vcs */ SIVAL(outbuf,smb_vwv3+1,max_recv); /* max buffer. LOTS! */ SIVAL(outbuf,smb_vwv5+1,0x10000); /* raw size. full 64k */ SIVAL(outbuf,smb_vwv7+1,sys_getpid()); /* session key */ SIVAL(outbuf,smb_vwv9+1,capabilities); /* capabilities */ put_long_date(outbuf+smb_vwv11+1,t); SSVALS(outbuf,smb_vwv15+1,TimeDiff(t)/60); p = q = smb_buf(outbuf); if (!negotiate_spnego) { /* Create a token value and add it to the outgoing packet. */ if (global_encrypted_passwords_negotiated) { /* note that we do not send a challenge at all if we are using plaintext */ get_challenge(p); SSVALS(outbuf,smb_vwv16+1,8); p += 8; } p += srvstr_push(outbuf, p, lp_workgroup(), -1, STR_UNICODE|STR_TERMINATE|STR_NOALIGN); DEBUG(3,("not using SPNEGO\n")); } else { int len = negprot_spnego(p); SSVALS(outbuf,smb_vwv16+1,len); p += len; DEBUG(3,("using SPNEGO\n")); } SSVAL(outbuf,smb_vwv17, p - q); /* length of challenge+domain strings */ set_message_end(outbuf, p); return (smb_len(outbuf)+4); }