mirror of
https://github.com/obarthel/amiga-smbfs.git
synced 2025-12-08 14:58:35 +00:00
Olaf Barthel
2f0d253eef
- In proc.c, smb_setup_header() initialized the SMB header length field with a number which was too large by four bytes. Consequently, what was later committed to the wire would have four trailing data bytes which could contain random values. This often didn't do much harm, but it seems that Samba 3.2.4 and Windows Vista don't like the looks of the trailing junk bytes. git-svn-id: file:///Users/olsen/Code/migration-svn-zu-git/logical-line-staging/amiga-smbfs/trunk@20 26594b9e-b914-4e86-b7a1-9402bd427170
125 lines
3.7 KiB
C
Executable File
125 lines
3.7 KiB
C
Executable File
/*
|
|
* $Id: quad_math.c,v 1.3 2009-04-14 11:32:51 obarthel Exp $
|
|
*
|
|
* :ts=4
|
|
*
|
|
* SMB file system wrapper for AmigaOS, using the AmiTCP V3 API
|
|
*
|
|
* Copyright (C) 2000-2009 by Olaf `Olsen' Barthel <obarthel -at- gmx -dot- net>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#ifndef _QUAD_MATH_H
|
|
#include "quad_math.h"
|
|
#endif /* _QUAD_MATH_H */
|
|
|
|
/****************************************************************************/
|
|
|
|
/* Divide a 64 bit integer by a 32 bit integer, filling in a 64 bit quotient
|
|
and returning a 32 bit remainder. */
|
|
ULONG
|
|
divide_64_by_32(QUAD * dividend,ULONG divisor,QUAD * quotient)
|
|
{
|
|
QUAD dividend_cdef = (*dividend);
|
|
ULONG dividend_ab = 0;
|
|
LONG i;
|
|
|
|
quotient->High = quotient->Low = 0;
|
|
|
|
for(i = 0 ; i < 64 ; i++)
|
|
{
|
|
/* Shift the quotient left by one bit. */
|
|
quotient->High = (quotient->High << 1);
|
|
|
|
if((quotient->Low & 0x80000000UL) != 0)
|
|
quotient->High |= 1;
|
|
|
|
quotient->Low = (quotient->Low << 1);
|
|
|
|
/* Shift the dividend left by one bit. We start
|
|
* with the most significant 32 bit portion.
|
|
*/
|
|
dividend_ab = (dividend_ab << 1);
|
|
|
|
if((dividend_cdef.High & 0x80000000UL) != 0)
|
|
dividend_ab |= 1;
|
|
|
|
/* Now for the middle 32 bit portion. */
|
|
dividend_cdef.High = (dividend_cdef.High << 1);
|
|
|
|
if((dividend_cdef.Low & 0x80000000UL) != 0)
|
|
dividend_cdef.High |= 1;
|
|
|
|
/* Finally, the least significant portion. */
|
|
dividend_cdef.Low = (dividend_cdef.Low << 1);
|
|
|
|
/* Does the divisor actually divide the dividend? */
|
|
if(dividend_ab >= divisor)
|
|
{
|
|
dividend_ab -= divisor;
|
|
|
|
/* We could divide the divisor. Keep track of
|
|
* this and take care of an overflow condition.
|
|
*/
|
|
quotient->Low++;
|
|
if(quotient->Low == 0)
|
|
quotient->High++;
|
|
}
|
|
}
|
|
|
|
return(dividend_ab);
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
/* Subtract a 64 bit integer from another 64 bit integer, producing a
|
|
64 bit integer difference, returning a 32 bit integer that indicates
|
|
whether or not an underflow occured. */
|
|
ULONG
|
|
subtract_64_from_64_to_64(const QUAD * const minuend,const QUAD * const subtrahend,QUAD * difference)
|
|
{
|
|
QUAD extended_minuend;
|
|
|
|
/* We may have to borrow if the minuend is less than the
|
|
subtrahend, so we set up a local variable to track
|
|
any underflow this might produce. */
|
|
extended_minuend.High = 0;
|
|
extended_minuend.Low = minuend->High;
|
|
|
|
/* First step: take care of the least significant word. If
|
|
that produces a local underflow, borrow from the most
|
|
significant word. */
|
|
if(minuend->Low < subtrahend->Low)
|
|
{
|
|
/* Borrow, and if there's nothing to be borrowed,
|
|
remember that we had an underflow. */
|
|
if(extended_minuend.Low-- == 0)
|
|
extended_minuend.High--;
|
|
}
|
|
|
|
difference->Low = minuend->Low - subtrahend->Low;
|
|
|
|
/* Second step: take care of the most significant word. If
|
|
that produces a local underflow, remember that. */
|
|
if(extended_minuend.Low < subtrahend->High)
|
|
extended_minuend.High--;
|
|
|
|
difference->High = extended_minuend.Low - subtrahend->High;
|
|
|
|
/* Return the underflow, if any. */
|
|
return(extended_minuend.High);
|
|
}
|