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 }