← Back to branch summary

~ubuntu-core-dev/synaptic/ubuntu

« back to all changes in this revision

Viewing changes to common/raptoptions.cc

  • Committer: niemeyer
  • Date: 2003-02-02 17:10:39 UTC
  • Revision ID: gustavo@niemeyer.net-20030202171039-5fe39d63e4ac20f4
Importing current CVS code into trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
common/raptoptions.cc
 
1
/* raptoptions.cc - configuration handling
 
2
 * 
 
3
 * Copyright (c) 2000, 2001 Conectiva S/A 
 
4
 * 
 
5
 * Author: Alfredo K. Kojima <kojima@conectiva.com.br>
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or 
 
8
 * modify it under the terms of the GNU General Public License as 
 
9
 * published by the Free Software Foundation; either version 2 of the
 
10
 * License, or (at your option) any later version.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License
 
18
 * along with this program; if not, write to the Free Software
 
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 
20
 * USA
 
21
 */
 
22
 
 
23
 
 
24
 
 
25
#include "config.h"
 
26
#include "i18n.h"
 
27
#include <fstream>
 
28
#include <strstream>
 
29
 
 
30
#include <apt-pkg/error.h>
 
31
#include <apt-pkg/configuration.h>
 
32
#include <apt-pkg/tagfile.h>
 
33
#include <apt-pkg/policy.h>
 
34
#include <apt-pkg/sptr.h>
 
35
#include <apt-pkg/strutl.h>
 
36
 
 
37
 
 
38
#include "rconfiguration.h"
 
39
#include "raptoptions.h"
 
40
 
 
41
 
 
42
RAPTOptions *_roptions = new RAPTOptions;
 
43
 
 
44
using namespace std;
 
45
 
 
46
ostream &operator<<(ostream &os, const RAPTOptions::packageOptions &o)
 
47
{
 
48
  os << o.isNew;
 
49
  return os;
 
50
}
 
51
 
 
52
istream &operator>>(istream &is, RAPTOptions::packageOptions &o)
 
53
{
 
54
  is >> o.isNew;
 
55
  return is;
 
56
}
 
57
 
 
58
 
 
59
bool RAPTOptions::store()
 
60
{
 
61
  ofstream out;
 
62
  if(!RPackageOptionsFile(out)) 
 
63
    return false;
 
64
 
 
65
  for(packageOptionsIter it = _roptions->_packageOptions.begin();
 
66
      it != _roptions->_packageOptions.end(); 
 
67
      it++) 
 
68
    {
 
69
      // we only write out if it's new and the pkgname is not empty
 
70
      if( (*it).second.isNew && !(*it).first.empty() ) 
 
71
          out << (*it).first << " " << (*it).second << endl;
 
72
    }
 
73
  return true;
 
74
}
 
75
 
 
76
 
 
77
bool RAPTOptions::restore()
 
78
{
 
79
  string pkg, line;
 
80
  packageOptions o;
 
81
 
 
82
  ifstream in;
 
83
  if(!RPackageOptionsFile(in)) 
 
84
    return false;
 
85
 
 
86
  // new stuff
 
87
  while(!in.eof()) {
 
88
    getline(in, line);
 
89
    istrstream strstr(line.c_str());
 
90
    strstr >> pkg >> o >> ws;
 
91
    _packageOptions[pkg] = o;
 
92
  }
 
93
 
 
94
  // pining stuff
 
95
  string File = _config->FindFile("Dir::Etc::Preferences");
 
96
 
 
97
  if( !FileExists(File) )
 
98
    return true;
 
99
 
 
100
  FileFd Fd(File,FileFd::ReadOnly);
 
101
  pkgTagFile TF(&Fd);
 
102
  if (_error->PendingError() == true) {
 
103
    return false;
 
104
  }
 
105
  pkgTagSection Tags;
 
106
  while (TF.Step(Tags) == true) {
 
107
      string Name = Tags.FindS("Package");
 
108
      if (Name.empty() == true)
 
109
        return _error->Error(_("Invalid record in the preferences file, no Package header"));
 
110
      if (Name == "*")
 
111
        Name = string();
 
112
 
 
113
      const char *Start;
 
114
      const char *End;
 
115
      if (Tags.Find("Pin",Start,End) == false)
 
116
        continue;
 
117
 
 
118
      const char *Word = Start;
 
119
      for (; Word != End && isspace(*Word) == 0; Word++);
 
120
 
 
121
      // Parse the type, we are only interesseted in "version" for now
 
122
      pkgVersionMatch::MatchType Type;
 
123
      if (stringcasecmp(Start,Word,"version") == 0 && Name.empty() == false)
 
124
        Type = pkgVersionMatch::Version;
 
125
      else 
 
126
        continue;
 
127
      for (; Word != End && isspace(*Word) != 0; Word++);
 
128
 
 
129
      setPackageLock(Name.c_str(), true);
 
130
    }
 
131
 
 
132
  // deborphan stuff
 
133
  rereadOrphaned();
 
134
  
 
135
  return true;
 
136
}
 
137
 
 
138
void RAPTOptions::rereadOrphaned() {
 
139
  // forget about any previously orphaned packages
 
140
  for(packageOptionsIter it = _roptions->_packageOptions.begin();
 
141
      it != _roptions->_packageOptions.end(); 
 
142
      it++) 
 
143
    {
 
144
      (*it).second.isOrphaned = false;
 
145
    }
 
146
 
 
147
  //mvo: call deborphan and read package list from it
 
148
  //     TODO: make deborphan a library to make this cleaner
 
149
  FILE *fp;
 
150
  char buf[255];
 
151
  char cmd[] = "/usr/bin/deborphan";
 
152
  //FIXME: fail silently if deborphan is not installed - change this?
 
153
  if(!FileExists(cmd))
 
154
    return;
 
155
  fp = popen(cmd, "r");
 
156
  if(fp==NULL) {
 
157
    //cerr << "deborphan failed" << endl;
 
158
    return;
 
159
  }
 
160
  while(fgets(buf, 255, fp) != NULL) {
 
161
    //mvo: FIXME this sucks (remove newline at end)
 
162
    buf[strlen(buf)-1] = 0;
 
163
    //cout << "buf: " << buf << endl;
 
164
    setPackageOrphaned(buf, true);
 
165
  }
 
166
  pclose(fp);
 
167
}
 
168
 
 
169
 
 
170
bool RAPTOptions::getPackageOrphaned(const char *package)
 
171
{
 
172
    string tmp = string(package);
 
173
 
 
174
    if (_packageOptions.find(tmp) == _packageOptions.end())
 
175
        return false;
 
176
 
 
177
    //cout << "getPackageOrphaned("<<package<<") called"<<endl;
 
178
    return _packageOptions[tmp].isOrphaned;
 
179
}
 
180
 
 
181
 
 
182
void RAPTOptions::setPackageOrphaned(const char *package, bool flag)
 
183
{
 
184
  //cout << "orphaned called pkg: " << package << endl;
 
185
    _packageOptions[string(package)].isOrphaned = flag;
 
186
}
 
187
 
 
188
   
 
189
bool RAPTOptions::getPackageLock(const char *package)
 
190
{
 
191
    string tmp = string(package);
 
192
 
 
193
    if (_packageOptions.find(tmp) == _packageOptions.end())
 
194
        return false;
 
195
 
 
196
    return _packageOptions[tmp].isLocked;
 
197
}
 
198
 
 
199
 
 
200
void RAPTOptions::setPackageLock(const char *package, bool lock)
 
201
{
 
202
    _packageOptions[string(package)].isLocked = lock;
 
203
}
 
204
 
 
205
bool RAPTOptions::getPackageNew(const char *package)
 
206
{
 
207
    string tmp = string(package);
 
208
 
 
209
    if (_packageOptions.find(tmp) == _packageOptions.end())
 
210
        return false;
 
211
 
 
212
    return _packageOptions[tmp].isNew;
 
213
}
 
214
 
 
215
void RAPTOptions::setPackageNew(const char *package, bool lock)
 
216
{
 
217
    _packageOptions[string(package)].isNew = lock;
 
218
}
 
219
 
 
220
void RAPTOptions::forgetNewPackages()
 
221
{
 
222
  for(packageOptionsIter it = _roptions->_packageOptions.begin();
 
223
      it != _roptions->_packageOptions.end(); 
 
224
      it++) 
 
225
    {
 
226
      (*it).second.isNew = false;
 
227
    }
 
228
}
 
229
 
 
230
bool RAPTOptions::getFlag(const char *key)
 
231
{
 
232
    if (_options.find(key) != _options.end())
 
233
        return _options[string(key)] == "true";
 
234
    else
 
235
        return false;
 
236
}
 
237
 
 
238
        
 
239
string RAPTOptions::getString(const char *key)
 
240
{
 
241
    if (_options.find(key) != _options.end())
 
242
        return _options[string(key)];
 
243
    else
 
244
        return "";
 
245
}
 
246
 
 
247
   
 
248
void RAPTOptions::setFlag(const char *key, bool value)
 
249
{
 
250
    _options[string(key)] = string(value ? "true" : "false");
 
251
}
 
252
 
 
253
 
 
254
void RAPTOptions::setString(const char *key, string value)
 
255
{
 
256
    _options[string(key)] = value;
 
257
}