kresolvermanager.cpp
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "config.h"
00026
00027 #include <sys/types.h>
00028 #include <netinet/in.h>
00029 #include <limits.h>
00030 #include <unistd.h>
00031
00032 #ifdef HAVE_RES_INIT
00033 # include <sys/stat.h>
00034 # include <resolv.h>
00035 # include <time.h>
00036 #endif
00037
00038 #include <qapplication.h>
00039 #include <qstring.h>
00040 #include <qcstring.h>
00041 #include <qptrlist.h>
00042 #include <qtimer.h>
00043 #include <qmutex.h>
00044 #include <qthread.h>
00045 #include <qwaitcondition.h>
00046 #include <qsemaphore.h>
00047
00048 #include <kde_file.h>
00049 #include "kresolver.h"
00050 #include "kresolver_p.h"
00051 #include "kresolverworkerbase.h"
00052 #include "kresolverstandardworkers_p.h"
00053
00054 using namespace KNetwork;
00055 using namespace KNetwork::Internal;
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103 namespace
00104 {
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116 class ResInitUsage
00117 {
00118 public:
00119
00120 #ifdef HAVE_RES_INIT
00121 time_t mTime;
00122 int useCount;
00123
00124 # ifdef SHARED_LIBRESOLV
00125 QWaitCondition cond;
00126 QMutex mutex;
00127 # endif
00128
00129 bool shouldResInit(time_t &mTime)
00130 {
00131 if (mTime == time(NULL))
00132 return false;
00133
00134
00135 KDE_struct_stat st;
00136 if (KDE_stat("/etc/resolv.conf", &st) != 0)
00137 return false;
00138
00139 if (mTime < st.st_mtime)
00140 {
00141
00142 return true;
00143 }
00144 return false;
00145 }
00146
00147 void reResInit(time_t& mTime)
00148 {
00149
00150 res_init();
00151
00152 KDE_struct_stat st;
00153 if (KDE_stat("/etc/resolv.conf", &st) == 0)
00154 mTime = st.st_mtime;
00155 }
00156
00157 ResInitUsage()
00158 : mTime(0), useCount(0)
00159 { }
00160
00161
00162
00163
00164 void release()
00165 {
00166 # ifdef SHARED_LIBRESOLV
00167 QMutexLocker locker(&mutex);
00168 if (--useCount == 0)
00169 {
00170
00171 cond.wakeAll();
00172 }
00173 # else
00174
00175 # endif
00176 }
00177
00178
00179
00180
00181 void acquire(time_t &mTime)
00182 {
00183 # ifdef SHARED_LIBRESOLV
00184 mutex.lock();
00185
00186 if (shouldResInit(mTime))
00187 {
00188 if (useCount)
00189 {
00190
00191
00192
00193
00194 cond.wait(&mutex);
00195 }
00196 else
00197
00198 reResInit(mTime);
00199 }
00200 useCount++;
00201 mutex.unlock();
00202 # else
00203 if (shouldResInit(mTime))
00204 reResInit(mTime);
00205 # endif
00206 }
00207
00208 #else
00209 ResInitUsage()
00210 { }
00211
00212 bool shouldResInit(time_t&)
00213 { return false; }
00214
00215 void acquire(time_t&)
00216 { }
00217
00218 void release()
00219 { }
00220 #endif
00221
00222 } resInit;
00223
00224 }
00225
00226
00227
00228
00229
00230
00231
00232 static const int maxThreadWaitTime = 2000;
00233 static const int maxThreads = 5;
00234
00235 static pid_t pid;
00236
00237 KResolverThread::KResolverThread()
00238 : data(0L), resolverMTime(0)
00239 {
00240 }
00241
00242
00243 void KResolverThread::run()
00244 {
00245
00246
00247
00248
00249 KResolverManager::manager()->registerThread(this);
00250 while (true)
00251 {
00252 data = KResolverManager::manager()->requestData(this, ::maxThreadWaitTime);
00253
00254
00255 if (data)
00256 {
00257
00258
00259
00260
00261 ;
00262
00263
00264 data->worker->run();
00265
00266
00267 KResolverManager::manager()->releaseData(this, data);
00268
00269
00270 }
00271 else
00272 break;
00273 }
00274
00275 KResolverManager::manager()->unregisterThread(this);
00276
00277 }
00278
00279 bool KResolverThread::checkResolver()
00280 {
00281 #ifdef SHARED_LIBRESOLV
00282 time_t& mTime = resInit.mTime;
00283 #else
00284 time_t& mTime = resolverMTime;
00285 #endif
00286
00287 return resInit.shouldResInit(mTime);
00288 }
00289
00290 void KResolverThread::acquireResolver()
00291 {
00292 #ifdef SHARED_LIBRESOLV
00293 time_t& mTime = resInit.mTime;
00294 #else
00295 time_t& mTime = resolverMTime;
00296 #endif
00297
00298 #if defined(NEED_MUTEX) && !defined(Q_OS_FREEBSD)
00299 getXXbyYYmutex.lock();
00300 #endif
00301
00302 resInit.acquire(mTime);
00303 }
00304
00305 void KResolverThread::releaseResolver()
00306 {
00307 #if defined(NEED_MUTEX) && !defined(Q_OS_FREEBSD)
00308 getXXbyYYmutex.unlock();
00309 #endif
00310
00311 resInit.release();
00312 }
00313
00314 static KResolverManager *globalManager;
00315
00316 KResolverManager* KResolverManager::manager()
00317 {
00318 if (globalManager == 0L)
00319 new KResolverManager();
00320 return globalManager;
00321 }
00322
00323 KResolverManager::KResolverManager()
00324 : runningThreads(0), availableThreads(0)
00325 {
00326 globalManager = this;
00327 workers.setAutoDelete(true);
00328 currentRequests.setAutoDelete(true);
00329 initStandardWorkers();
00330
00331 pid = getpid();
00332 }
00333
00334 KResolverManager::~KResolverManager()
00335 {
00336
00337
00338
00339 for (workers.first(); workers.current(); workers.next())
00340 workers.current()->terminate();
00341 }
00342
00343 void KResolverManager::registerThread(KResolverThread* )
00344 {
00345 }
00346
00347 void KResolverManager::unregisterThread(KResolverThread*)
00348 {
00349 runningThreads--;
00350 }
00351
00352
00353 RequestData* KResolverManager::requestData(KResolverThread *th, int maxWaitTime)
00354 {
00356
00358
00359
00360
00361 QMutexLocker locker(&mutex);
00362 RequestData *data = findData(th);
00363
00364 if (data)
00365
00366 return data;
00367
00368
00369 availableThreads++;
00370 feedWorkers.wait(&mutex, maxWaitTime);
00371 availableThreads--;
00372
00373 data = findData(th);
00374 return data;
00375 }
00376
00377 RequestData* KResolverManager::findData(KResolverThread* th)
00378 {
00380
00381
00383
00384
00385 for (RequestData *curr = newRequests.first(); curr; curr = newRequests.next())
00386 if (!curr->worker->m_finished)
00387 {
00388
00389 if (curr->obj)
00390 curr->obj->status = KResolver::InProgress;
00391 curr->worker->th = th;
00392
00393
00394 currentRequests.append(newRequests.take());
00395
00396 return curr;
00397 }
00398
00399
00400 return 0L;
00401 }
00402
00403
00404 void KResolverManager::releaseData(KResolverThread *, RequestData* data)
00405 {
00407
00409
00410
00411
00412
00413 if (data->obj)
00414 {
00415 data->obj->status = KResolver::PostProcessing;
00416 }
00417
00418 data->worker->m_finished = true;
00419 data->worker->th = 0L;
00420
00421
00422 handleFinished();
00423 }
00424
00425
00426 void KResolverManager::handleFinished()
00427 {
00428 bool redo = false;
00429 QPtrQueue<RequestData> doneRequests;
00430
00431 mutex.lock();
00432
00433
00434
00435
00436 RequestData *curr = currentRequests.last();
00437 while (curr)
00438 {
00439 if (curr->worker->th == 0L)
00440 {
00441 if (handleFinishedItem(curr))
00442 {
00443 doneRequests.enqueue(currentRequests.take());
00444 if (curr->requestor &&
00445 curr->requestor->nRequests == 0 &&
00446 curr->requestor->worker->m_finished)
00447
00448 redo = true;
00449 }
00450 }
00451
00452 curr = currentRequests.prev();
00453 }
00454
00455
00456 while (RequestData *d = doneRequests.dequeue())
00457 doNotifying(d);
00458
00459 mutex.unlock();
00460
00461 if (redo)
00462 {
00463
00464
00465 handleFinished();
00466 }
00467 }
00468
00469
00470 bool KResolverManager::handleFinishedItem(RequestData* curr)
00471
00472 {
00473
00474
00475
00476 if (curr->worker->m_finished && curr->nRequests == 0)
00477 {
00478
00479 if (curr->obj)
00480 curr->obj->status = KResolver::PostProcessing;
00481
00482 if (curr->requestor)
00483 --curr->requestor->nRequests;
00484
00485
00486
00487 return true;
00488 }
00489 return false;
00490 }
00491
00492
00493
00494 void KResolverManager::registerNewWorker(KResolverWorkerFactoryBase *factory)
00495 {
00496 workerFactories.append(factory);
00497 }
00498
00499 KResolverWorkerBase* KResolverManager::findWorker(KResolverPrivate* p)
00500 {
00502
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514 KResolverWorkerBase *worker;
00515 for (KResolverWorkerFactoryBase *factory = workerFactories.first(); factory;
00516 factory = workerFactories.next())
00517 {
00518 worker = factory->create();
00519
00520
00521 worker->input = &p->input;
00522
00523 if (worker->preprocess())
00524 {
00525
00526 if (worker->m_finished)
00527 p->status = KResolver::PostProcessing;
00528 else
00529 p->status = KResolver::Queued;
00530 return worker;
00531 }
00532
00533
00534 delete worker;
00535 }
00536
00537
00538 return 0L;
00539 }
00540
00541 void KResolverManager::doNotifying(RequestData *p)
00542 {
00544
00545
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569 if (p->obj)
00570 {
00571
00572 p->obj->mutex.lock();
00573 KResolver* parent = p->obj->parent;
00574 KResolverResults& r = p->obj->results;
00575
00576 if (p->obj->status == KResolver::Canceled)
00577 {
00578 p->obj->status = KResolver::Canceled;
00579 p->obj->errorcode = KResolver::Canceled;
00580 p->obj->syserror = 0;
00581 r.setError(KResolver::Canceled, 0);
00582 }
00583 else if (p->worker)
00584 {
00585
00586 p->worker->postprocess();
00587
00588
00589
00590 r = p->worker->results;
00591
00592
00593 r.setAddress(p->input->node, p->input->service);
00594
00595
00596
00597
00598 p->obj->errorcode = r.error();
00599 p->obj->syserror = r.systemError();
00600 p->obj->status = !r.isEmpty() ?
00601 KResolver::Success : KResolver::Failed;
00602 }
00603 else
00604 {
00605 r.empty();
00606 r.setError(p->obj->errorcode, p->obj->syserror);
00607 }
00608
00609
00610 if (!p->obj->waiting && parent)
00611
00612
00613
00614 QApplication::postEvent(parent, new QEvent((QEvent::Type)(ResolutionCompleted)));
00615
00616
00617 p->obj->mutex.unlock();
00618 }
00619 else
00620 {
00621
00622 if (p->worker)
00623 p->worker->postprocess();
00624 }
00625
00626 delete p->worker;
00627
00628
00629
00630
00631 delete p;
00632
00633
00634 notifyWaiters.wakeAll();
00635 }
00636
00637
00638
00639
00640 void KResolverManager::enqueue(KResolver *obj, RequestData *requestor)
00641 {
00642 RequestData *newrequest = new RequestData;
00643 newrequest->nRequests = 0;
00644 newrequest->obj = obj->d;
00645 newrequest->input = &obj->d->input;
00646 newrequest->requestor = requestor;
00647
00648
00649
00650 if ((newrequest->worker = findWorker(obj->d)) == 0L)
00651 {
00652
00653
00654 obj->d->status = KResolver::Failed;
00655 obj->d->errorcode = KResolver::UnsupportedFamily;
00656 obj->d->syserror = 0;
00657
00658 doNotifying(newrequest);
00659 return;
00660 }
00661
00662
00663
00664 if (requestor)
00665 requestor->nRequests++;
00666
00667 if (!newrequest->worker->m_finished)
00668 dispatch(newrequest);
00669 else if (newrequest->nRequests > 0)
00670 {
00671 mutex.lock();
00672 currentRequests.append(newrequest);
00673 mutex.unlock();
00674 }
00675 else
00676
00677 doNotifying(newrequest);
00678 }
00679
00680
00681
00682 void KResolverManager::dispatch(RequestData *data)
00683 {
00684
00685
00686
00687
00688 QMutexLocker locker(&mutex);
00689
00690
00691 newRequests.append(data);
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719 if (availableThreads == 0 && runningThreads < maxThreads)
00720 {
00721
00722
00723
00724 KResolverThread *th = workers.first();
00725 while (th && th->running())
00726 th = workers.next();
00727
00728 if (th == 0L)
00729
00730 th = new KResolverThread;
00731 else
00732 workers.take();
00733
00734 th->start();
00735 workers.append(th);
00736 runningThreads++;
00737 }
00738
00739 feedWorkers.wakeAll();
00740
00741
00742 workers.first();
00743 while (workers.current())
00744 {
00745 if (!workers.current()->running())
00746 workers.remove();
00747 else
00748 workers.next();
00749 }
00750 }
00751
00752
00753 bool KResolverManager::dequeueNew(KResolver* obj)
00754 {
00755
00756
00757
00758
00759 KResolverPrivate *d = obj->d;
00760
00761
00762 RequestData *curr = newRequests.first();
00763 while (curr)
00764 if (curr->obj == d)
00765 {
00766
00767
00768 d->status = KResolver::Canceled;
00769 d->errorcode = KResolver::Canceled;
00770 d->syserror = 0;
00771 newRequests.take();
00772
00773 delete curr->worker;
00774 delete curr;
00775
00776 return true;
00777 }
00778 else
00779 curr = newRequests.next();
00780
00781
00782 curr = currentRequests.first();
00783 while (curr)
00784 if (curr->obj == d)
00785 {
00786
00787
00788 d->mutex.lock();
00789
00790 d->status = KResolver::Canceled;
00791 d->errorcode = KResolver::Canceled;
00792 d->syserror = 0;
00793
00794
00795 curr->obj = 0L;
00796 curr->input = 0L;
00797 if (curr->worker)
00798 curr->worker->input = 0L;
00799
00800 d->mutex.unlock();
00801 }
00802 else
00803 curr = currentRequests.next();
00804
00805 return false;
00806 }
00807
00808
00809
00810 void KResolverManager::dequeue(KResolver *obj)
00811 {
00812 QMutexLocker locker(&mutex);
00813 dequeueNew(obj);
00814 }
This file is part of the documentation for kdecore Library Version 3.4.0.