Every file in this commit makes a call to a function which returns a value.

Each file also didn't check the return value.

This commit changes it so that every single non-checked call in these files
is checked.

1 files changed, 6 insertions, 2 deletions

diff --git a/libopie2/opiemm/opieexif.cpp b/libopie2/opiemm/opieexif.cpp
index de49937..653216c 100644
--- a/libopie2/opiemm/opieexif.cpp
+++ b/libopie2/opiemm/opieexif.cpp
@@ -160,97 +160,97 @@ int ExifData::ReadJpegSections (QFile & infile, ReadMode_t ReadMode)
 
             if (a >= 6){
 
                 owarn << "too many padding bytes" << oendl;
                 return false;
 
             }
         }
 
         if (marker == 0xff){
             // 0xff is legal padding, but if we get that many, something's wrong.
             return false;
         }
 
         Sections[SectionsRead].Type = marker;
 
         // Read the length of the section.
         lh = (uchar) infile.getch();
         ll = (uchar) infile.getch();
 
         itemlen = (lh << 8) | ll;
 
         if (itemlen < 2) {
             return false;;
         }
 
         Sections[SectionsRead].Size = itemlen;
 
         Data = (uchar *)malloc(itemlen+1); // Add 1 to allow sticking a 0 at the end.
         Sections[SectionsRead].Data = Data;
 
         // Store first two pre-read bytes.
         Data[0] = (uchar)lh;
         Data[1] = (uchar)ll;
 
         got = infile.readBlock((char*)Data+2, itemlen-2); // Read the whole section.
         if (( unsigned ) got != itemlen-2){
             return false;
         }
         SectionsRead++;
 
         switch(marker){
 
             case M_SOS:   // stop before hitting compressed data
                 // If reading entire image is requested, read the rest of the data.
                 if (ReadMode & READ_IMAGE){
                     unsigned long size;
 
-                    size = QMAX( 0ul, infile.size()-infile.at() );
+                    size = infile.size()-infile.at();
                     Data = (uchar *)malloc(size);
                     if (Data == NULL){
                         return false;
                     }
 
                     got = infile.readBlock((char*)Data,  size);
                     if (( unsigned ) got != size){
                         return false;
                     }
 
                     Sections[SectionsRead].Data = Data;
                     Sections[SectionsRead].Size = size;
                     Sections[SectionsRead].Type = PSEUDO_IMAGE_MARKER;
                     SectionsRead ++;
                     //HaveAll = 1;
                 }
                 return true;
 
             case M_EOI:   // in case it's a tables-only JPEG stream
                 owarn << "No image in jpeg!" << oendl;
                 return false;
 
             case M_COM: // Comment section
         // pieczy 2002-02-12
         // now the User comment goes to UserComment
         // so we can store a Comment section also in READ_EXIF mode
         process_COM(Data, itemlen);
                 break;
 
             case M_JFIF:
                 // Regular jpegs always have this tag, exif images have the exif
                 // marker instead, althogh ACDsee will write images with both markers.
                 // this program will re-create this marker on absence of exif marker.
                 // hence no need to keep the copy from the file.
                 free(Sections[--SectionsRead].Data);
                 break;
 
             case M_EXIF:
                 // Seen files from some 'U-lead' software with Vivitar scanner
                 // that uses marker 31 for non exif stuff.  Thus make sure
                 // it says 'Exif' in the section before treating it as exif.
                 if ((ReadMode & READ_EXIF) && memcmp(Data+2, "Exif", 4) == 0){
                     process_EXIF((uchar *)Data, itemlen);
                 }else{
                     // Discard this section.
                     free(Sections[--SectionsRead].Data);
                 }
                 break;
@@ -764,97 +764,101 @@ int ExifData::Exif2tm(struct ::tm * timeptr, char * ExifTime)
 
     if (a == 6){
         timeptr->tm_isdst = -1;
         timeptr->tm_mon -= 1;      // Adjust for unix zero-based months
         timeptr->tm_year -= 1900;  // Adjust for year starting at 1900
         return true; // worked.
     }
 
     return false; // Wasn't in Exif date format.
 }
 
 //--------------------------------------------------------------------------
 // Contructor for initialising
 //--------------------------------------------------------------------------
 ExifData::ExifData()
 {
     ExifData::Whitebalance = -1;
     ExifData::MeteringMode = -1;
     ExifData::FlashUsed = -1;
     Orientation = 0;
     Height = 0;
     Width = 0;
     IsColor = 0;
     Process = 0;
     FocalLength = 0;
     ExposureTime = 0;
     ApertureFNumber = 0;
     Distance = 0;
     CCDWidth = 0;
     ExposureBias = 0;
     ExposureProgram = 0;
     ISOequivalent = 0;
     CompressionLevel = 0;
     MotorolaOrder = 0;
 }
 
 ExifData::~ExifData()
 {
 }
 
 //--------------------------------------------------------------------------
 // process a EXIF jpeg file
 //--------------------------------------------------------------------------
 bool ExifData::scan(const QString & path)
 {
     int ret;
 
     QFile f(path);
-    f.open(IO_ReadOnly);
+    if ( !f.open(IO_ReadOnly) ) {
+	owarn << "Unable to open file " << f.name() << " readonly" << oendl;
+	DiscardData();
+	return false;
+    }
 
     // Scan the JPEG headers.
     ret = ReadJpegSections(f, READ_EXIF);
 
     if (ret == false){
         owarn << "Not JPEG file!" << oendl;
         DiscardData();
         f.close();
         return false;
     }
     f.close();
     DiscardData();
 
     //now make the strings clean,
     // for exmaple my Casio is a "QV-4000   "
     CameraMake = CameraMake.stripWhiteSpace();
     CameraModel = CameraModel.stripWhiteSpace();
     UserComment = UserComment.stripWhiteSpace();
     Comment = Comment.stripWhiteSpace();
     return true;
 }
 
 //--------------------------------------------------------------------------
 // Does the embedded thumbnail match the jpeg image?
 //--------------------------------------------------------------------------
 #ifndef JPEG_TOL
 #define JPEG_TOL 0.02
 #endif
 bool ExifData::isThumbnailSane() {
   if (Thumbnail.isNull()) return false;
 
   // check whether thumbnail dimensions match the image
   // not foolproof, but catches some altered images (jpegtran -rotate)
   if (ExifImageLength != 0 && ExifImageLength != Height) return false;
   if (ExifImageWidth != 0 && ExifImageWidth != Width) return false;
   if (Thumbnail.width() == 0 || Thumbnail.height() == 0) return false;
   if (Height == 0 || Width == 0) return false;
   double d = (double)Height/Width*Thumbnail.width()/Thumbnail.height();
   return (1-JPEG_TOL < d) && (d < 1+JPEG_TOL);
 }
 
 
 
 static QImage flip_image( const QImage& img );
 static QImage rotate_90( const QImage& img );
 static QImage rotate_180( const QImage& );
 static QImage rotate_270( const QImage& );